Tippek és trükkök

TARTALOMJEGYZÉK

BEVEZETÉS

Minden számítógép-tulajdonos igyekszik megismerni gépe tulajdonságait, kezelését, előnyeit, esetleges fogyatékosságait. Egy ilyen sokoldalú - elfogultság nélkül mondhatjuk -, nagytudású gép kiismerése viszont szinte lehetetlennek tűnik. Minden rejtett tulajdonság már csak azért is nehezen általánosítható, mert különböző kialakítású gépek vannak forgalomban. Van amelyik csak angolul ért, van amelyik angol-német billentyűzet, ill. üzemmód között átváltható.
Példáink, megállapításaink bekapcsolás utáni alapállapotú, 128 K kiépítésű, angol-német átkapcsolási lehetőséggel rendelkező gépekre vonatkoznak.
A kezelési utasításból valami halvány képzetünk lehet a memória-kiosztás és memóriaszervezés bonyolultságáról. Nem elrettentésként; de az Enterprise memóriával való gazdálkodás első látásra követhetetlenül bonyolultnak tűnik. Egy átlag gépfelhasználónak természetesen alig kell törődnie a szegmensek különböző felhasználásával. A szegmensek belapozásával, megosztásával és a konkrét állapot számontartásával profi módon foglalkozik az operációs rendszer, az EXOS. Alapértelmezésben, bekapcsolás utáni állapotban a Z80-as és a NICK által kiszolgálható szegmensek "helyzetét" az 1. ábrán követhetjük.

1. ábra Alapbelapozás

A Z80-as processzor által kiszolgált, egyidejűleg "látott" szegmenseket a gép a 0-3 lapra lapozza be, ezeket a B0H-B3H pontokon keresztül vizsgálhatjuk:

Az egyes lapokra éppen belapozott szegmensek lekérdezésére a következő program szolgál:

100 ! a belapozott szegmensek
110 FOR I=176 TO 179
120 PRINT USING "£. lapra £££. Szegmenst lapozta":I-176,IN(I)
130 NEXT
140 ! IN(n) beolvas a portrol
150 ! 176-179 portokon keresztul cimez a Z80 processzor

A programok futása közben ez az állapot változik, de mire a kurzor és az ok felirat megjelenik a képernyőn, általában ismét ez a helyzet tapasztalható, hacsak nem változtatunk rajta. Egyelőre ne tegyük, hacsak nem akarjuk, hogy a gép "elszálljon". Basic utasítással csak az egyes lapra lapozzunk be, a többi lap által látott szegmensszám csak gépi kódú programból és csak nagy körültekintéssel módosítható.
Böngésszünk tovább a memóriában! A memóriacímek és azok tartalma az alapállapot esetére vonatkoznak, de ha ezen keresztül bizonyos dolgokat sikerül meg- és felismerni, akkor talán sikerül boldogulni később bonyolultabb helyzetek esetében is.

1. MEMÓRIATÉRKÉP

05-07H CP/M részére foglalt
08-37H RST rutinok ugrási címei és átmeneti tárak
38-3EH IT (megszakítási) rutin
3F-118H EXOS és CP/M által használt terület

A továbbiakban a

• RST 8 lapozó,
• RST 10 makro hívó,
• RST 18 EXOS hibakezelő,
• RST 20 Basic hibakezelő,
• RST 30 EXOS rendszerhívó,
• RST 38 megszakítási rutinokra,

azok felhasználására még visszatérünk.

200-247H Basic rendszerváltozók
Ezek tartalma a programbeírás, parancsok és utasítások végrehajtása közben változik. Vannak olyan címek, melyeket az új programsor beírásakor a tokenizálás közben más célra is felhasznál a rendszer, mint amit itt felsorolunk.
A Basic-ben a rendszerváltozó terület elejét a Z80-as processzor IX regisztere tartalmazza. Ennek értéke 200H. A programok futása és szerkesztése közben e címhez viszonyítva relatív címzéssel vagy közvetlen kijelöléssel módosítja a tárolt értéket a rendszerprogram. Minthogy az egyes címek tartalmát PEEK-kel mi is ki akarjuk olvasni, vagy POKE-kal módosítani kívánjuk, célszerű ezeket a címeket decimális értékükkel is ismerni.

Parancsmódban értékének megváltoztatása a rendszer összeomlásához vezethet, de programfutás közben is óvatosan bánjunk a direkt beavatkozás lehetőségével.

A verem kifejezés a szövegünkben két értelmezésben is előfordul. Ez az átmeneti tár mindig felülről lefelé, azaz a magasabb memóriacímtől az alacsonyabb felé építkezik. Az egyik verem a Z80-as processzor-regiszterek tartalmának tárolására és a gépi kódú szubrutinok visszatérési címének tárolására szolgál (l. DBBH címen).
A másik, amelyre ebben a könyvben többször hivatkozunk, a változók, Basic utasítások végrehajtásához szükséges bejegyzések tárolására szolgál. Azt, hogy ebben a veremben hol tartunk, azt egyrészt a 228H rendszerváltozó címről tudhatjuk meg, másrészt, minthogy a processzor is használja ezeket az adatokat, ill. címeket az IY regiszter is felveszi ezt az értéket.

Az előző memóriatartalmak vizsgálatára alkalmas a 2. program.

1 PROGRAM "Dec538.bas"
100 ! 538-554 dec. memoriacimek tartalma
110 ALLOCATE 10
120 CODE X=HEX$("201")
130 ! ha ALLOCSTE nincs CODE agyonuti a programot!
140 FOR I=538 TO 553 STEP 2
150   READ A$
160   PRINT I;PEEK(I)+256*PEEK(I+1);":";A$
170 NEXT
180 DATA Basic program eleje
190 DATA CODE altal meg nem hasznalt
200 DATA ALLOCATE altal foglalt terulet
210 DATA ALLOCATE utani elso szabad hely
220 DATA ,,verem alja,verem teteje

1 PROGRAM "PRG_Hosz.bas"
100 ! program hossza rendszervaltoyo tartalmabol
110 LET ELEJE=PEEK(544)+256*PEEK(545)
120 LET VEGE=PEEK(566)+256*PEEK(567)-1
130 IF VEGE>16384 THEN LET ELEJE=16384
140 ! csak a 0. program elejet mutatja az 554 cim
150 PRINT " Program eleje:";ELEJE
160 LET VEGE=PEEK(566)+256*PEEK(567)-1
170 PRINT " Program vege: ";VEGE
180 PRINT "Program hossza= ";VEGE-ELEJE;" byte"
190 ! ellenorzes INFO-val

Az egy és két byte hosszon tárolt két elővéletlen számból állítja elő az RND értékét. Az RND 65 535 különféle értéket vehet fel, de periodikus ismétlődés csak 524 287 érték után következik be. Az RND kiszámítása (X+32768)/65536 - összefüggéssel történik. A képletbe X értékét a 246-247H memóriarekesz tartalma szolgáltatja. A memóriarekesz tartalma az előző tartalomtól és a 211H címen tárolt értéktől függ. A fenti állítások ellenőrzésére a 4. program szolgál.

1 PROGRAM "RND.bas"
100 ! RND kiismerese
110 LET A=RND:LET E=1
120 PRINT "most (211H)=";PEEK(529)
130 PRINT :PRINT
140 LET B=PEEK(582):LET C=PEEK(583)
150 IF C>128 THEN
160   LET C=256-C:LET E=-1
170 END IF
180 PRINT "RND (ahogy a gep adja):";A
190 PRINT "es ahogy kifigyelheto: ";(32768+E*256*C+B)/65536
200 ! ez az 1. szegmens CAA9H rutinjanak Basic szintu modelje
210 PRINT :PRINT
220 PRINT "legkozelebb (211H)=";B
230 GOTO 110

1 PROGRAM "INPUT.bas"
100 ! INPUT PUFFER tartalmanak vizsgalata
110 INPUT V$
120 LET K=PEEK(584)
130 FOR C=584 TO 583+K
140   LET I=PEEK(C):LET A$="."
150   IF I>32 AND I<160 THEN LET A$=CHR$(I)
160   PRINT C;I;A$
170 NEXT
180 ! puffer elso eleme a hossz
190 ! INPUT adatsor veget 0 jelzi

Ennek ismeretében közvetlenül az INPUT pufferből is kiolvashatjuk (adott esetben majd kezelhetjük) az ott lévő szöveget. De ez a terület általános pufferként is szolgál LIST, RENUMBER esetén is.

100 ! utolso hibauzenet
110 LET I=PEEK(1094)
120 ! 1094dec a hibauzenet puffer eleje
130 FOR K=1094 TO 1094+I
140   LET A=PEEK(K):LET A$=CHR$(A)
150   IF K=1094 THEN LET A$="hossz"
160   PRINT USING "£££ £££££":A;A$
170 NEXT

A hibaüzenetek természetesen a ROM megfelelő helyein vannak. A német verziójú gépek esetében az üzenetek a 4. szegmens 26 659-30 352dec címei között lévő területen találhatók meg a következő elrendezésben: sorszám, üzenethossz, és a hibaüzenet karakteres formában. Erről a 7. program segítségével könnyen meggyőződhetünk.

100 ! nemet hibauzenetek tarolasa
110 LET X=26659
120 DO 130 LET V=SPEEK(4,X) ! uzenet sorszama
140   IF V<>0 THEN
150     PRINT V;
160     LET H=SPEEK(4,X+1) ! uzenet hossza
170       FOR Y=X+2 TO X+H+1
180       PRINT CHR$(SPEEK(4,Y));
190     NEXT
200     PRINT :LET X=X+H+2
210   END IF
220 LOOP UNTIL X>30000 OR V=0
230 ! rst 20 BASIC hibauzenetek
240 LET X=28381
250 DO
260   LET H=SPEEK(4,X) ! uzenet hossza
270   FOR Y=X+1 TO X+H
280     PRINT CHR$(SPEEK(4,Y));
290   NEXT
300   PRINT :LET X=X+H+1
310 LOOP UNTIL X>30352

Az angol hibaüzenetek ilyen könnyen nem találhatók meg, ravasz módon memóriakímélő konverzióval tárolja a ROM karaktereket az 1. szegmensen az E038H címtől kezdődően.

1 PROGRAM "Inp_puf.bas"
100 ! INPUT PROMPT kiiras 496H pufferbol
110 !INPUT A
120 ! vagy az egyik, vagy a masik INPUT sor kell
130 INPUT PROMPT "Hogy is van ez?":A
140 LET H=PEEK(1174) !kiirando uzenet hossza
150 FOR C=1174 TO 1174+H
160   LET T=PEEK(C):LET A$="."
170   IF T>31 AND T<160 THEN LET A$=CHR$(T)
180   ! A$ a puffercimen levo karakter
190   PRINT C;T;A$
200   ! Vigzazz, a USING is hasznalja ezt a puffert!
210 NEXT

A 110-130. programsorok közül a program kipróbálása esetén csak az egyikre van szükség. A program további része kiolvassa az INPUT üzenetként képernyőre küldendő szöveget PROMPT alkalmazásával, ill. anélkül.

100 ! RAM bejegyzes E54H cimtol
110 LET U$="  £££   £££   £££"
120 PRINT
130 PRINT " cim szegmens pr."
140 FOR C=3666 TO 3680 STEP 2
150   PRINT USING U$:C;PEEK(C);PEEK(C+1)
160 NEXT
170 ! ujabb inditasok elott EDIT n-nel ujabb programokat irj be

Követhető, hogy mindig a legalacsonyabb sorszámú, még szabad szegmens bejegyzésekre kerül sor. A memóriatérkép méretéből következik, hogy egyidejűleg nyolc (most nincs is több) szegmens bejegyzése lehetséges.

1 PROGRAM "Kulcsszo.bas"
100 ! kulcsszo leirora mutato cimtabla
110 PRINT "token tablacim leiro cime kulcsszo"
120 FOR T=0 TO 92
130   LET C=3687+T*3 ! cimmutato
140   LET A=PEEK(C):LET F=PEEK(C+1)
150   LET K=A+256*F ! kulcsszo leiro cime az 5. szegmensen
160   PRINT USING "  ££    ££££     £££ £££  ":T,C,A,F;
170   CALL KULCSSZO
180 NEXT
190 END
200 DEF KULCSSZO
210   LET H=SPEEK(5,K+5) ! kulcsszo hossza
220   FOR I=K+5 TO K+5+H
230     PRINT CHR$(SPEEK(5,I)); ! kulcsszo karakterei
240   NEXT
250   PRINT
260 END DEF

A 10. program futásának eredménye

A futás eredményeként kapott lista első oszlopában a kulcsszó tokenje, a második oszlopban az adott kulcsszóra vonatkozó adatok memóriabeli helyét találjuk. A harmadik-negyedik oszlop a leíróra mutató cím két byte-ja. Ezt a leírót még majd tüzetesebben megvizsgáljuk. Az utolsó oszlopban az adott tokenhez tartozó kulcsszó található.
Ezek a leíróra mutató címek (hiszen RAM területen vagyunk) átírhatók és így megváltoztathatjuk az egyes kulcsszavak végrehajtásának menetét, de hogy ebből értelmes dolog adódjon, ahhoz igen alaposan végig kell gondolni a dolgokat. Erre példát a gépi kódú programozás kapcsán látunk majd.

A kulcsszavak címtáblája után a beépített függvények azonosító és ugrótáblája következik. Ez a 3968dec címen kezdődik, ha még nem "tunningoltuk" a gépet. Ennek a táblának a felépítését a 11. program futtatásával, ill. a mellékelt lista segítségével érthetjük meg.

1 PROGRAM "Fuggveny.bas"
100 ! mast hajt vegre ha cimet atirom
110 ! fuggvenyek vegrehajtas elso cimtabla
115 PRINT "tipus  fv.nev     rutincim  itt van"
120 FOR V=3968 TO 4800
130   LET TIPUS=PEEK(V):LET HOSSZ=PEEK(V+1)
140   LET CIM=V+2+HOSSZ ! a vegrehatas atiranyitasa itt lehet
150   LET A=PEEK(CIM):LET F=PEEK(CIM+1) ! vegrehajto rutin cimenek also-felso byte-ja
160   LET T$="n"
170   IF TIPUS=13 THEN LET T$="$"
180   LET N$=""
190   FOR I=V+2 TO V+1+HOSSZ
200     LET N$=N$&CHR$(PEEK(I))
210   NEXT
220   LET V=I+4
230   PRINT USING " £  <£££££££££ £££ £££    c:££££":T$,N$,A,F,CIM
240 NEXT

Egy byte jelzi, hogy a függvény numerikus, vagy string művelet végzésére alkalmas-e. Egy byte az azonosítandó függvénynév hosszát tartalmazza, ezután következik a függvénynév karakteres formában. A név után két byte a függvény végrehajtó rutinjának címét tartalmazza.
Ez a rutin (alapértelmezésű gépen) az 1. szegmensen van, de a 3. lapra belapozva kerül végrehajtásra. A futás eredményének listájában az utolsó oszlop azt a címet tartalmazza, ahova benyúlva adott esetben egy függvény végrehajtását más rutinra irányíthatjuk át. Való igaz, hogy az eddig leírt címek tartalmáról a számítógép rendszerprogramja gondoskodik. Azonban nem véletlenül helyezték el ezeket az itt tárolt adatokat egy olyan memóriaterületre, amelyhez egy átlagnál kissé jobban felkészült géptulajdonos - akár Basic utasítás - segítségével is hozzáférhet. A következőkben viszont olyan memóriaterület következik, melyet a legkezdőbb gépfelhasználó is - tudatosan, vagy sem - maga tölt fel saját programjával.
Az alapállapotú gépen a Basic program 12DBH 4827dec címtől kezdődő területen kezdődik. Arról, hogy ez a cím valóban igaz-e, a 220H-221H memóriarekeszek tartalmának kiolvasásával győződhetünk meg. A programsorok tárolásának mikéntjét a 12. program segítségével vizsgálhatjuk. ("tarolas.bas")

100 ! programtarolas vizsgalo
110 ! bekapcsolas utan 0. program
120 ! megjegyzes sorok nelkul futtatni
130 LET VEGE=PEEK(566)+256*PEEK(567)-1
140 LET KEZDET=PEEK(538)+256*PEEK(539)
150 FOR I=KEZDET TO VEGE
160   LET T=PEEK(I)
170   PRINT I;T,
180   IF T>32 AND T<128 THEN PRINT CHR$(T);
190   PRINT
200 NEXT

A futás eredményét és értelmezését a következőkben tekinthetjük át. A futás eredménye alapján látható, hogy a programsor hossza egy byte-on kerül tárolásra, tehát egy programsor max. 255 byte lehet, míg a legrövidebb programsor 7 byte hosszú. A programsor száma a következő két byte. Az itt tárolható maximális érték 9999 lehet. Minden Basic sor kulcsszóval kezdődik. Az interpreter a program listázásának (a program szerkezetének jobb áttekinthetősége érdekében) - a FOR-NEXT, IF-THEN-ELSE, DO/LOOP stb. szerkezeteknél tagolt kiírást biztosít.
A skatulyázás mélységét - egy bizonyos határig az egyre beljebb kezdett kiírást - a sorszám utáni byte jelzi. A kiírások egyre beljebb való kezdésének mértéke a TEXT üzemmódtól függ. A következő byte jelzi, hogy kulcsszó következik, majd az a sorszám, ahányadik helyen a ROM-ban lévő táblában az adott kulcsszó és a hozzátartozd információk elhelyezkednek. Ez a ROM táblázat az 5. szegmensen (az első lapon értelmezett), 323dec címtől kezdődő területén található. Mielőtt ezt a táblázatot vizsgálnánk, mi magunk is tanulmányozhatjuk a különböző utasítások tárolásának módját.

A 13. program 40. sorába mindig más és más programsort beírva vizsgálhatjuk annak memóriában való elhelyezkedését. Lehet, hogy az 50. sorba is kell írni valamit, mert az interpreter nemcsak a sor beíráskor végez bizonyos ellenőrzéseket, hanem a futtatáskor (pl. a FOR-NEXT szerkezeteket) is.

10 ! sortarolas vizsgalata
20 GOTO 100
30 !
40 ! ide a vizsgalando sor
50 !
60 ! eddig ugyanigy kell beirni akkor igaz, hogy a 40. sor eleje 4873 cimen van
100 LET H=PEEK(4873) ! 40.sor hossza
110 FOR L=4873 TO 4872+H
120   LET J=PEEK(L) ! a tarolt byte
130   PRINT L;J, ! cim, tartalom
140   IF J>31 AND J<160 THEN PRINT CHR$(J); ! ha kiirhato a karakter, ird ki
150   PRINT
160 NEXT

Lesznek olyan kulcsszavak, melyeket nem hajlandó a számítógép a programsorba beépíteni. Pedig a számítógép ezeket is tokenizálja és az alapján értelmezi, valamint végrehajtja azokat parancsmódban. Azt, hogy mi alapján dönti el a gép, hogy egy adott kulcsszót utasításként, vagy parancsként, esetleg így is, úgy is elfogadjon, azt az elóbb hivatkozott ROM tábla alapján végzi el. Vizsgáljuk meg ezt a táblázatot a 14. program segítségével.

1 PROGRAM "Kulcssz2.bas"
100 ! Kulcsszo keiro 5. szegmensen
110 OUT 177,5 ! a vizsgalathoz belapozzuk az 5. szegmenst
120 FOR N=30123 TO 31127
130   LET A=PEEK(N)
140   GOSUB 200 ! byte-bit atvaltas
150   LET N=N+1:LET B=PEEK(N) ! kulcsszo hossza
160   GOSUB 270 ! kulcsszo osszeallitas
170   LET N=N+4+B
180 NEXT
190 END
200 ! byte binaris kijelzese
210 LET O=128
220 FOR F=1 TO 8
230   PRINT INT(A/O);
240   LET A=MOD(A,O):LET O=O/2
250 NEXT
260 RETURN
270 ! kulcsszo osszeallitasa
280 FOR R=N+1 TO N+B
290   PRINT CHR$(PEEK(R)); ! karakterek kiirasa
300 NEXT
310 PRINT
320 RETURN

A program futásának eredménye:

0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 0 1 1 1 0 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 1 1 0 1 0 1 0 0 1 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 1 0 0 1 0 1 0 0 1 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 1 0 1 0 0 1 0 1 0 0 1 0 1 0 0 1 1 0 1 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 0 1 1 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 0 0 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 1 0 1 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 0 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1 0 0 0 1 1 0 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 1 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 0 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 1 1 0 1 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 1 0 0 0 0 1 0 1 0 1 0 0 1 0 0 1 0 1 0 0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0 0 1 0 0 1 1 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 1 0

ALLOCATE ASK AUTO CALL CAPTURE CASE CAUSE CLEAR CLOSE CODE CONTINUE COPY DATA DEF DEF DELETE DIM DISPLAY DO CHAIN EDIT ELSE ELSE IF END END DEF END HANDLER END IF END SELECT END WHEN ENVELOPE EXIT FOR GOSUB GOTO GRAPHICS HANDLER IMAGE IF IF INPUT LET LINE LIST LOAD LOOP MERGE NEW NEXT NUMERIC OPEN OPTION OK OUT PLOT POKE SPOKE PRINT PROGRAM RANDOMIZE READ REDIRECT REM RENUMBER RESTORE RETRY RETURN RUN SAVE SELECT SET SOUND START STOP INFO STRING TEXT TOGGLE TRACE TYPE VERIFY WHEN ! LLIST LPRINT EXT GET FLUSH LOOK PING DATE TIME WAIT ON

A futás eredményét tekintsük át a következőkben. A bitsorozat értelmezése, ha az adott bit értéke l, akkor a kulcsszó:

• 0 Parancsként használható
• 1 Programban használható
• 2 Blokk vége utasítás
• 3 Blokk eleje utasítás
• 4 Több utasítás is lehet egy sorban
• 5 Direkt végrehajtásban a változókat törli
• 6 A sor kulcsszó utáni része is tokenizálandó

A ROM-beli kulcsszó táblában, tehát a kulcsszó előtt annak felhasználási, alkalmazási és tokenizálási szabályaira utaló byte található, ennek figyelése alapján dönt az interpreter. A 15. program segítségével különböző szempontok szerint kigyűjthetjük az egy kategóriába tartozó, tehát rokonságban lévő kulcsszavakat.

1 PROGRAM "Kulcssz3.bas"
100 ! Kulcsszavak csoportositasa
110 DIM T$(14)
120 CLEAR TEXT
130 FOR I=1 TO 7 ! szempont kiiras
140   READ T$(I)
150   PRINT I;T$(I)
160 NEXT
170 PRINT
180 FOR I=8 TO 14
190   READ T$(I)
200   PRINT " ";CHR$(57+I);" ";T$(I)
210 NEXT
220 OUT 177,5 ! viszgalathoz belapoz
230 PRINT :PRINT :LET V=255
240 INPUT PROMPT "Melyik szempont alapjan? ":X$
250 LET X$=UCASE$(X$)
260 IF X$>="1" AND X$<="8" THEN
270   LET X=VAL(X$):LET V=X-1:LET W=1
280 END IF
290 IF X$>"A" AND X$<"H" THEN
300   LET X=ORD(X$)-64:LET V=X-1
310   LET X=X+7:LET W=0
320 END IF
330 IF V=255 THEN RUN
340 PRINT :PRINT T$(X)
350 FOR N=30123 TO 31127
360   LET A=PEEK(N) ! kulcsszo jelzo flag
370   LET H=PEEK(N+1) ! Kulcsszo hossz
380   IF (A BAND 2^V)/2^V=W THEN GOSUB 440
390   LET N=N+5+H ! vegrehajtasi cimek atlepese
400 NEXT
410 PRINT "Nyomj meg egy gombot!"
420 IF INKEY$="" THEN 420
430 RUN
440 ! ha a keresett bitnek megfelelo a kulcsszo akkor kiir
450 PRINT " ";
460 FOR K=N+2 TO N+H+1
470   PRINT CHR$(PEEK(K));
480 NEXT
490 PRINT
500 RETURN
510 DATA parancsmodban hasznalhato
520 DATA programban hasznalhato
530 DATA blokk vege utasitas
540 DATA blokk kezdete utasitas
550 DATA egy sorban tobb utasitas is lehet
560 DATA adattorlessel kezd
570 DATA sort kulcsszo utan is tokenizalja
580 DATA parancsmodban nem hasznalhato
590 DATA programban nem hasznalhato
600 DATA nem blokk vege utasitas
610 DATA nem blokk kezdete utasitas
620 DATA THEN utan nem hasznalhato
630 DATA nem adattorlessel kezd
640 DATA sort kulcsszo utan nem tokenizalja

Az előző programokkal és kulcsszó táblával kapcsolatban még egy kis kitérőt tehetünk.
A kulcsszó táblában két DEF és két IF kulcsszó található. A tokenizáló rutin az egy soros DEF, ill. IF struktúrákat másként értelmezi, mint a hasonló célú, de általában összetettebb blokkokat. Így a tokenizálás során és után kiderül, hogy blokk elejeként kell-e értelmezni az adott sort, és akkor blokk véget kell hozzá keresni, vagy sem. Ugyanakkor meg kell jegyezni, hogy a vizsgálatot többször végzi a számítógép, egyrészt a tokenizálás időszakában, másrészt a végrehajtás közben. Sajnos egyes esetekben nincs meg az összhang a beírás adta lehetőség, másrészt a végrehajtás során megvalósított vizsgálat között. A program beírás során pl. elfogad egy sorban több GOSUB utasítást kettősponttal elválasztva, de a végrehajtás közben olyan bejegyzést tesz a 206H rendszerváltozó címre, mely alapján a szubrutinból való visszatérés után a program futását a GOSUB-ot tartalmazó sor után fogja folytatni. Így tehát annak ellenére, hogy elfogadta a programsort a számítógép mint helyeset, a végrehajtás során elvész a kettőspont utáni programsor részlet. Próbáljuk ki és győződjünk meg ennek az állításnak igazáról a 16. program segítségével.

100 ! gosub hiba
110 LET A=0
120 GOSUB 200
130 ! <- ERROL NEM TUD ->
132 ! <- nem vegzi el ->
133 ! <-nem szamozza at->
140 GOSUB 300 :GOSUB 400 :GOSUB 500
150 PRINT A
160 END
200 LET A=A+1
210 PRINT "200-as szubrutin"
220 RETURN
300 LET A=A+1
310 PRINT "300-as szubrutin"
320 RETURN
400 LET A=A+1
410 PRINT "400-as szubrutin"
420 RETURN
500 LET A=A+1
510 PRINT "500-as szubrutin"
520 RETURN

Mielőtt azonban belemerülnénk ezeknek a részleteknek a boncolgatásába, folytassuk tovább a RAM feltérképezését.
A program által lefoglalt tárterület után a változókat tárolja a számítógép. Ez a terület változó nagyságú, és kezdete is függ a program hosszától. Azt, hogy egy adott esetben ennek a területnek mik a határai, azt a rendszerváltozó terület megfelelő címeiről olvashatjuk ki (17. program).

1 PROGRAM "Var_TBL.bas"
100 ! valtozo tabla mamoriabeli helye, merete
110 LET A=2 ! kiserletezz ertekadasokkal
120 ! vizsgald a hatasat: DIM,DEF,A$
130 LET ELEJE=PEEK(566)+256*PEEK(567)
140 LET VEGE=PEEK(564)+256*PEEK(565)
150 PRINT "Valtozo tabla eleje: ";ELEJE
160 PRINT "Valtozo tabla vege: ";VEGE
170 PRINT "valtozo tabla altal foglalt:";VEGE-ELEJE

Ezen a területen a gyanútlan szemlélőnek kusza összevisszaságban helyezkednek el a bejegyzések, pedig logikája nyomon követhető. Nézzünk bele a változóterület tárolására szolgáló memóriaterületbe a 18. program segítségével.

1 PROGRAM "Szam.bas"
100 ! szamabrazolas
110 LET SAMU=1.2345678 ! ezt valtoztasd
120 LET M=PEEK(566)+256*PEEK(567)
130 ! M az elsonek bejegyzett valtozo tarolasi helye
140 LET H=PEEK(M+3) ! valtozonev hossza
150 PRINT M+2;PEEK(M+2),"adattipus jelzo"
160 PRINT M+3;H,"valtozonev hossza"
170 FOR V=M+4 TO M+H+3 ! nev kiiras
180   PRINT V;PEEK(V);CHR$(PEEK(V))
190 NEXT
200 FOR V=M+H+4 TO M+H+8
210   LET T=PEEK(V) ! tarolt ertek
220   LET E=INT(T/16) !BCD elso tag
230   LET M=MOD(T,16) ! BCD masodik tag
240   PRINT V;T,E;M
250 NEXT
260 PRINT V;PEEK(V),"hatvanykitevo"

A numerikus változók értékét változó táblában 5+1 byte-on tárolja a gép. Egész típusú - 10 0000x10 00 nagyságú számokat két byte-on hexadecimális alakban találhatjuk a memóriában és a hatványkitevő tárolására szolgáló 6 byte tartalma 127. A 9999-nél nagyobb egészeket és a törtszámokat a gép BCD alakban ábrázolja.
Hogyan néz ki egy decimális szám BCD alakban? A tízes számrendszerű szám egy helyi értékének ábrázolásához négy bit bőven elegendő, így lehetőség van arra, hogy nyolc biten (egy byte-on) két decimális számjegyet ábrázoljunk úgy, hogy az egyik (alacsonyabb helyi értékű) számjegyet binárisan a 0-3. biten, a másik a magasabb helyi értékű számjegyet pedig a 4-7. biten tároljuk.
Azaz 29DEC=0010 1001 BCD, igaz ez a szám a szokványos módon kiolvasva (hiszen PEEK-kel kiolvashatjuk) egészen más értéket reprezentál. Ezért kell tudni, hogy a kiolvasott érték BCD-ben van! Ez a számábrázolás-tárolás kissé pazarló, hiszen öt byte-on tízjegyű decimális szám ábrázolható, míg tisztán bináris (vagy hexadecimális) formában ugyanezen az 5 byte-on 2 * 749 *10^14 értékű a maximálisan ábrázolható szám. Ez a pazarlás a műveletek elvégzése során időben megtérül. A binárisan kódolt decimális rendszerben (BCD) a 10-es alapot megtartjuk, azaz a szomszédos számok egymásnak tízszeresei, de a számokat binárisan fejezzük ki.
Az elmondottak jobb megvilágítására, ill. a szerzett ismeret hasznosítására futtassuk le a 19. programot.

100 ! PEEK-el kiolvasott ertek visszaalakitasa
110 LET PROBA=1988.12 ! csak tort szamot
120 LET M=PEEK(566)+256*PEEK(567)
130 LET H=PEEK(M+3)
140 IF PEEK(M+H+9)=127 THEN 330
150 LET SZORZO=.0000000001
160 LET SUMMA=0
170 FOR V=M+H+4 TO M+H+8
180   LET T=PEEK(V)
190   LET E=MOD(T,16) ! BCD elso tag
200   LET SUMMA=SUMMA+E*SZORZO:LET SZORZO=SZORZO*10
210   LET M=INT(T/16) ! BCD masodik taz
220   LET SUMMA=SUMMA+M*SZORZO:LET SZORZO=SZORZO*10
230   PRINT T,M;E
240 NEXT
250 LET KI=PEEK(V)
260 LET S=(KI BAND 128)/128
270 LET KI=KI-64-128*S
280 IF S=1 THEN LET ELOJEL=-1
290 IF S=0 THEN LET ELOJEL=1
300 PRINT KI,"hatvanykiyevo"
310 PRINT ELOJEL*SUMMA*10^(KI+1)
320 END
330 PRINT "Ez egesz szam, erre mas szabaly igaz!"

A PEEK utasítással kiolvasott érték mellett a táblázat mutatja azt az értéket, ahogyan értelmezni kell a memóriarekeszek tartalmát. Az öt byte-on tárolt számsorozat csak a számjegyeket tárolja szépen egymás után, a helyi értéket, a nagyságrendet a karakterisztika határozza meg. Alapértelmezés l00, ilyenkor a kitevő byte 40H azaz PEEK-kel kiolvasva 64. A számítógépben maximálisan ábrázolható szám hatványkitevőjének tárolásához nincs szükség a 7. bitre ez az előjel tárolására szolgál a valós számok esetében. Ha ez a bit 1 akkor a tárolt szám negatív. Természetesen nemcsak numerikus változókat tárol a számítógép. A tárolt adat jellegét a bejegyzés 3. byte-ja jelzi. A jelző byte értéke:

• 0 numerikus változó A
• 1 string változó A$
• 2 numerikus tömbváltozó A(1)
• 3 string tömbváltozó A$(1)
• 4 felhasználói függvény def név
• 5 felhasználói függvény def név $
• 8 gépi kódú függvény
• 12 függvény numerikus érték SIN (X)
• 13 függvény string értékkel STR$ (A)
• 16 referencia adat

Jobban nyomon követhetjük a jelző byte logikáját, a bitek külön-külön való vizsgálatával.

• 0. bit numerikus=0, stringváltozó=1
• 1. bit értéke 1, ha tömbváltozó
• 2. bit értéke 1, ha felhasználói függvény
• 3. bit értéke 1, ha gépi kódú függvény
• 4. bit értéke 1, ha referencia adat.

A számítógép 1 szegmensén az Enterprise több konstanst tárol. Ezek tárolt értékét és visszafejtett értékét mutatja a 20. program futtatása során.

1 PROGRAM "Konstans.bas"
100 ! 1. szegmens konstansainak visszafejtese
110 FOR CIM=16524 TO 16590 STEP 7
120   LET S=0:LET O=1
130   FOR V=CIM+5 TO CIM STEP-1
140     LET T=SPEEK(1,V)
150     LET E=INT(T/16):LET M=MOD(T,16) ! BCD visszaalakitasa
160     LET S=S+(E+M/10)/O ! helyi ertek es osszegzes
170     LET O=100*O
180   NEXT
190   LET J=SPEEK(1,CIM+6) ! a kitevo
200   LET L=(J BAND 128)/128
210   LET J=J-64-128*L
220   LET E=(L=1)-(L=0) ! elojel
230   PRINT "konstans=";E*S*10^J
240 NEXT

Nézzük meg mi a helyzet, akkor ha a programunk első soraiban több értékadás is történik. Ilyenkor már derengeni kezdhet az adott változó táblabeli bejegyzés első két byte-jának, a láncolási címnek a jelentősége (21. program).

1 PROGRAM "Dump.bas"
100 ! Dump
110 LET A1=1:LET A$="samu" ! ertekadasok probahoz
120 LET A=2.2:LET SAMU$="?"
130 LET A2=1
140 DIM B(2),C$(3)
150 DEF Y(X)=2*X
160 FOR I=3531 TO 3593 STEP 2 ! DCBH tablazat cimei alapjan kereses indul
170   LET K=PEEK(I)+256*PEEK(I+1) ! lancolasi cim kiszamitasa
180   IF K>4827 THEN !ha a valtozo BASIC RAM teruleten van
190     LET S=I
200     GOSUB 250
210     LET I=S
220   END IF
230 NEXT
240 END
250 ! valtozo tablaban lancolasi cimen vegigfut
260 LET I=K ! vizsgalt adatcsomag eleje
270 PRINT PEEK(K+2); !valtozo tipus
280 FOR W=1 TO PEEK(K+3)
290   PRINT CHR$(PEEK(K+3+W)); ! valtozo neve
300 NEXT
310 PRINT
320 LET K=PEEK(I)+256*PEEK(I+1)
330 IF K<4827 THEN RETURN ! vissza ha BASIC ele mutat a cim, lanc vege
340 GOTO 250

A program az eddig tárgyaltak összefoglalása is lehetne. A változó tábla bejegyzett konstansokat a DCBH címen kezdődő táblázat adatai segítségével keresi meg a rendszerprogram. Az adatok egymás után, láncolva helyezkednek el a változó táblában. A láncolási címek alapján található meg egy-egy azonos táblázatbeli címre "feltűzött" változók sora. A DUMP program ezt a vizsgálatot végzi el, és addig keres az azonosító láncban, amíg a lánc végére nem ér. A lánc végét az jelzi, hogy a láncolási cím visszamutat a Basic-ben írt felhasználói program elé. Az előbbi gondolatmenet visszafelé is végigvezethető, így a DCBH tábla bejegyzésein keresztül megkereshetjük egy-egy változó tárolási helyét a memóriában.

A 22. program a más számítógépek függvénykészletében megtalálható VARPTR hatását utánozza.

1 PROGRAM "Varptr.bas"
100 ! varptr
110 LET A1=1:LET A$="samu" ! ertekadas probahoz
120 LET A=2.2:LET SAMU$="?"
130 LET A2=1
140 DIM B(2),C$(3)
150 INPUT PROMPT "a keresett valtozo neve ":K$
160 CALL VARPTR
170 PRINT :GOTO 150
180 END
190 !
200 DEF VARPTR
210   FOR I=3531 TO 3593 STEP 2 !DCBH tabla alapjankeres
220     LET K$=UCASE$(K$)
230     LET K=PEEK(I)+256*PEEK(I+1) ! lancolasi cim meghatarozasa
240     IF K>4827 THEN ! keres ha BASIC teruletre mutat a cim
250       LET S=I
260       LET I=K
270       LET E$=""
280       FOR W=1 TO PEEK(K+3) ! nev azonositas
290         LET E$=E$&CHR$(PEEK(K+3+W))
300       NEXT
310       IF E$=K$ THEN PRINT "VARPTR(";K$;")=";K ! ha megtalalta a csomag cimet kiirja
320       LET K=PEEK(I)+256*PEEK(I+1) ! lancot tovabb elemez
330       IF K<4827 THEN 350 ! egy vizsgalt lanc vege
340       GOTO 260
350       LET I=S
360     END IF
370     IF E$=K$ THEN EXIT FOR ! ne keress tovabb, ha megvan
380   NEXT
390   IF E$<>K$ THEN PRINT "Ilyen nincs!"
400 END DEF

A programban az első sorokon (a használhatóság kedvéért) értékadásokat végeztünk. A keresett változó nevét INPUT-ként közölhetjük programunkkal. A DCBH táblázatba bejegyzett ugrási címek vizsgálata után ugrik a változó táblába a kereső rutin. Az eredeti (a gép rendszerprogramjának) kereső rutinja RST 10/8E a DCBH egészét nem vizsgálja végig. Egy, a változó névből képzett áltoken - egy-egy byte hosszú sorszám - segítségével csak a DCB táblázat n. helyéről induló címláncot vizsgálja. Ha a kapcsolószám alapján elér a mi kereső programunk egy adat tárolási terület elejére, akkor a bejegyzés 4. helyén kezdődő változónevet összehasonlítja az általunk beírt K$-keresett változó névvel. Amennyiben az azonosítás sikerül, úgy kiírható a változó tárolási helyének címe, vagy akár összes adata és értéke.

RST rutinok

Az RST rutinokat minden Z80-as processzorra épülő számítógépben speciális, gyakran előforduló programrészek, vizsgálatok elvégzésére használják fel. Ezek felhasználása ugyan a gépi kódú programok írásánál lehet fontos, de az Enterprise RST 10 rutinjai olyan elegáns programozási ötleteket, fogásokat tartalmaznak, melyek tanulmányozásán keresztül a programozási logikánk - a Basic nyelvű is - sokat fejlődhet.
A következőkben fő ismérveivel felsoroljuk a RST 10 rutinok működését. A RST 10 rutinra a 0 lapon lévő 10H címen kell belépni.
Ez a 0. lapon lévő címen keresztüli meghívási lehetőség azért szükséges, mert pl. az 5. szegmensen lévő Basic utasításokat végrehajtó rutinok gyakran használják az 1. szegmensen lévő szintaktikai elemzést biztosító utasítássort (makrót). A RST 10 rutin elemzéséből láthatjuk, hogy a program következő byte-jai egy-egy újabb rutin meghívását biztosítják, egészen addig amíg a következő byte nem nulla.

Tekintsük át a RST 10H után következő számok értelmezését:

A 99H-A0H rutinok programfutás (ill. tokenizálás) közben szintaktikai elemzést végeznek és kiértékelik az aktuális kifejezést. A kiértékelés eredményét a tárba helyezi.

Az A1-B2 közti rutinok Basic kulcsszóval elérhető függvények végrehajtását biztosítják. Ezekre a végrehajtó RST 10 rutinokra a szintaktikai elemzés után tér át a rendszerprogram.

A1	C1. szegmens C68DH FREE függvény végrehajtó rutinja az aktuális program részére kijelölt memóriaterületen még rendelkezésre álló szabad byte-ok számát adja meg.
A2	1. szegmens C399H ATN a tár tetején lévő számot, mint egy szög tangensét értelmezi. Ebből kiszámítja a szög értékét radiánban. Az eredményt a tárban adja.
A3	1. szegmens C368H ASIN a tár tetején lévő számot, mint egy szög szinuszát értelmezi. Eredményként a tárba a szög értékét adja radiánban. A számításhoz felhasználja azt a trigonometriai összefüggést, hogy és a számítást az A2 rutin segítségével végzi el.
A4	1. szegmens CB86H A radiánokban adott szög szinuszát számítja ki a közelítéssel. A konstansok értékét a RST 10-92 rutin segítségével olvassa be.
A5	1. szegmens C518H A radiánban adott szög koszinuszát számolja ki a cos x = sin (x + PI/2) összefüggés felhasználásával.
A6	1. szegmens CC9FH A radiánokban adott szög tangensét határozza meg a összefüggéssel. Érdemes ezt a végrehajtó rutint tüzetesebben elemezni, hogy a RST 10 rutinok hívás sorozatának logikáját megértsük: RST10 - A6 TAN(X) kiszámításának rutinja CC9F CCA0 CCA1 CCA2 CCA3 CCA4 CCA5 CCA6 CCA7 CCA8 CCA9 D7 15 98 A4 95 92 07 0C A4 0F 00 RST 10 rutinok hívása X még egyszer a verembe aritmetikai reg. be X kiszámítja SIN(X)-et regiszterből verembe X verembe a 7. konstanst 7. konstans = PI/2 a két utolsó elem összeadása (SIN(X)+PI/2) SIN(X) két utolsó elem hányadosa SIN(X)/(SIN(X)+PI/2) RST 10 rutinhívás vége
A7	1. szegmens C5F0H A tár tetején lévő számot mint hatványkitevőt értelmezi és kiszámítja az ex értékét.
A8	1. szegmens CA80H A 201H rendszerváltozó értékétől függően elvégzi a tár tetején lévő radiánban értelmezett szög fokokra való átszámítását.
A9	1. szegmens C586H A 201H rendszerváltozó értékétől függően elvégzi a tár tetején lévő fokban értelmezett szögérték radiánokra való átszámítását.
AA	1. szegmens C8A7H A tár tetején lévő szám tízes alapú logaritmusát számítja ki.
AB	1. szegmens C98DH Szintaktikai elemzés nélkül kiszámítja a MOD (X,Y) értékét. X értéke a tárban IY+9 címen van, az Y értéke a tár legutoljára bejegyzett értéke IY címen van.
AC	1. szegmens CC52H A Basic verem tetején lévő szám négyzetgyökét kiszámítja a Newton-féle iteráció segítségével. A 25. program ennek Basic változatát mutatja be. 1 PROGRAM "RST10-AC.bas" 100 ! RST 10-AC BASIC megvalositasa 110 INPUT X 120 IF X<0 THEN PRINT "Negativ argumentum":STOP 130 LET A=X:LET K=0 140 IF X>1 THEN 150   LET K=K+1 ! normal alakra 160   LET X=X/10 170   GOTO 140 180 END IF 190 LET Y=X-X*SQR(.8)+.223607 ! kezdo ertek 200 FOR I=0 TO 4 210   LET Y=(X/Y-Y)/2+Y 220   GOSUB 270 230 NEXT 240 GOSUB 270 250 PRINT "kontroll: ";SQR(A) 260 END 270 LET K1=K:LET Y1=Y 280 IF K=0 THEN 350 290 IF INT(K/2)=K/2 THEN 300   LET K=K/2 310 ELSE 320   LET Y=Y*.316227766 330   LET K=(K+1)/2 340 END IF 350 PRINT ," " Y*10^K 360 LET K=K1:LET Y=Y1 370 RETURN
AD	1. szegmens CA8EH A tár tetején lévő elem reciprokát számítja ki.
AE	1. szegmens C778H A lebegőpontos számnál nem nagyobb egész számot állítja elő. A Basic INT függvény szintaktikai elemzés nélküli végrehajtó rutinja.
AF	1. szegmens CB17H Az akkumulátorban megadott decimális jegy pontosságra kerekíti a Basic verem tetején lévő lebegőpontos számot. A Basic ROUND függvény szintaktikai elemzés nélküli végrehajtó rutinja.
B0	1. szegmens C7B0H A tár utoljára bejegyzett elemét hatványkitevőnek értelmezi az IY+9 címen lévő következő elemet alapnak tekinti. Ezekkel az adatokkal ki- számítja az alap n. hatványát. A végrehajtó rutin kristálytiszta logikával dolgozik (l. blokkdiagram, 2. ábra), a megvalósítás Basic programmal is modellezhető. Ezt szemlélteti a 26. program. 1 PROGRAM "RST10-B0.bas" 100 ! RST 10-B0 BASIC megvalostitasa 110 INPUT PROMPT "alap :":X 120 INPUT PROMPT "kitevo :":Y 130 PRINT "eredmeny: "; 140 IF Y<>0 THEN 170 150 LET W=1 ! minden szam 0. hatvanya 1 160 GOTO 300 170 IF X<>0 THEN 200 180 LET W=0 ! 0 minen hatvanya 0 190 GOTO 300 200 LET F=SGN(Y):LET K=ABS(Y) ! kitevo elojele es ABS erteke 210 IF Y<>INT(Y) THEN 280 220 LET W=1 230 FOR I=1 TO K ! egesz kitevo eseten ismetelt szorzas 240   LET W=W*X 250 NEXT 260 IF F=-1 THEN LET W=1/W ! negativ kitevo miatt reciprok ertek 270 GOTO 300 280 LET E=2.718281828 ! ln alapszama 290 LET W=E^(Y*LOG(X)) ! tortkitevo eseten alkalmazando osszefugges 300 PRINT W 310 PRINT "kontroll: " X^Y Látható az alkalmazott összefüggés a tört kitevőjű hatvány esetében. Minthogy az alap logaritmusával számol, törtkitevőjű hatvány esetében az alap nem lehet negatív.
B1	1. szegmens C820H A tár legfelső elemének tizedespont utáni részét törli. Ez a rutin a Basic IP függvény végrehajtását biztosítja.
B2	1. szegmens CBF9H A Basic SGN függvény végrehajtó rutinja. A tárba bejegyzett legfelső elem előjelétől, ill. értékétől függően -1, 0 vagy 1 értéket ad eredményül.
B3	1. szegmens C1D9H A B5 rutin segítségével megkeresi, ill. bejegyzi az E54H területen kezdődő RAM térképbe a C regiszterben adott szegmensszámot.
B4	1. szegmens C1B9H Első szabad RAM szegmenset C-ben hozott program számára lefoglalja. Elvégzi a 20DH 20BH rendszerváltozók értékének átírását.
B5	1. szegmens C1EFH C regiszterben hozott szegmensszám (E54H címen kezdődő) RAM táblabeli bejegyzettségét vizsgálja. Ha már be van jegyezve Z flag=1
B6	1. szegmens C1F9H C regiszterben hozott programszámot az E54H címen kezdődő területen a 20CH rendszerváltozó értéke által meghatározott hosszon keres. Ha bejegyzést talált Carry=0.
B7	1. szegmens D1F3H Funkcióbillentyű hatásának átdefiniálását végzi az EXOS 0B rutin meghívásával, valamint a SET végrehajtása.
B8	1. szegmens D2ACH A gépi feltételek azonosítása a D2DD címen kezdődő táblázat segítségével ASK, SET és TOGGLE végrehajtó rutinjához. Ha azonosítható az alábbi táblázat valamelyik eleme, akkor A, B, C értékét táblázatból kiveszi és Carry=1-gyel tér vissza DE az azonosított feltétel táblabeli címét mutatja a 27. program. 1 PROGRAM "RST10-B8.bas" 100 ! ASK TOGGLE feltetelek RST10-B8 110 PRINT "Feltetel B C A" 120 FOR I=53981 TO 54313 STEP 5 ! azonosito tabla 130   LET A=SPEEK(1,I)*256+SPEEK(1,I+1) ! azonosito szoveg 140   LET H=SPEEK(1,A):LET A$="" ! feltetel szoveg hossza 150   FOR K=1 TO H !feltetel karakterei 160     LET A$=A$&CHR$(SPEEK(1,A+K)) 170   NEXT 190   LET C$=H$(PEEK(I+3)) 210   LET D$=H$(PEEK(I+3)) 230   LET E$=H$(PEEK(I+4)) 240   PRINT USING "<££££££££££   £££   £££   £££":A$,C$,D$,E$ 250 NEXT 260 END 270 ! dec -> hex$ atalakito 280 DEF H$(N)=CHR$(INT(N/16)+48-7*(INT(N/16)>9))&CHR$(MOD(N,16)+48-7*(MOD(N,16)>9)) A táblázatot és a kiolvasott értékeket a következőkben tekinthetjük át:   feltétel B C A 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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 DEFAULT CHANNEL TIMER KEY CLICK RATE DELAY INTERRUPT STOP KEY NET CODE TAPE SOUND PROTECT LEVEL FAST SAVE SOUND STOP BUFFER SPEAKER SERIAL BAUD FORMAT VIDEO MODE COLOR COLOUR BORDER Y X BIAS STATUS EDITOR VIDEO KEY BUFFER REM1 REM2 NET CHANNEL NUMBER MACHINE PRIORITY ATTRIBUTES PALETTE COLOR COLOUR PAPER INK CHARACTER CURSOR CHARACTER COLOR COLOUR SCROLL ON OFF UP DOWN BEAM ON OFF LINE STYLE MODE 80 84 85 80 87 8A 8B 80 88 89 93 82 80 8C A2 A3 80 A1 80 8D 8F 8E 80 0 91 80 96 97 97 99 98 9B 9C 9A 80 9D 9E 9F A4 A5 80 94 92 95 A6 61 43 63 63 50 49 4B 00 2E 4D 4D 00 53 73 55 44 00 53 73 00 2E 4D 80 84 85 80 87 8A 8B 80 88 89 93 82 80 8C A2 A3 80 A1 80 8D 8F 8E 80 90 91 80 96 97 97 99 98 9B 9C 9A 80 9D 9E 9F A4 A5 80 94 92 95 A6 61 43 63 63 50 49 4B 00 2E 4D 4D 00 53 73 55 44 00 53 73 00 2E 4D 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 65 65 65 65 65 65 66 00 66 66 66 00 66 66 66 66 00 65 65 00 65 65
B9	1. szegmens D430H DELETE és LIST kulcsszavak után alkalmazható szöveges FIRST, LAST sorszám és sorszámtartomány meghatározás. HL-be tölti az első, DE-be az utolsó programsor számát.
BA	1. szegmens D4A8H Sorszámmal adott programsorokat Carry' értékétől függően listázza, vagy törli. Listázás végrehajtását a Carry'= 1 esetében.
BB	1. szegmens D546H A Basic AUTO parancs kiértékelése, ill. az alapértelmezésű sorszám és lépésköz meghatározása.
BC	1. szegmens D5CFH A Basic RENUMBER parancs kiértékelése és végrehajtása.
BD	1. szegmens DA48H PRINT utasítás után, formatált kiírásra utaló utasításkódok kiértékelése. A kiírási formátumot A értéke határozza meg USING=3, AT=2, £=1, ha egyik sem, akkor akkumulátor tartalma 0
BE	1. szegmens DA9DH PRINT végrehajtó rutin. A PRINT formátus soron belüli alakítására használható segéd információk kiértékelése TAB, vessző, pontosvessző.
BF	1. szegmens DF4BH, ha angol, vagy 4. szegmens EDE0H, ha német üzemmód HL-ben hozott hibasorszám alapján a hibaüzenetet a ROM megfelelő helyéről a 446H címen kezdődő hibaüzenet pufferbe tölti. A hibaüzenetek sokfélesége ellenére nem minden esetben tud részletes hibaüzenetet kiírni, ilyenkor sorszámtól függően EXOS, vagy általános típusra utaló üzenetet ad.
C0	1. szegmens D746H A WAIT Basic utasítás végrehajtó rutinja.
C1	1. szegmens D773H A blokkok egymásba ágyazását, annak szabályszerűségét vizsgálja. Az egymásba ágyazás mélységét, a skatulyázást, mely legfeljebb 127 szintű lehet, a programsor tárolás során a sorszám utáni byte-on írja be. Amennyiben a 7. bit is használatba kerülne e vizsgálat során, akkor hibajelzést ad. Egyébként a skatulyázás jelző 7. bitjét futás közben jelzőbitként használja a rendszer.
C2	1. szegmens D7B5H Az EXOS 1F rutin felhasználásával az időpont beállítását végzi el. A TIME Basic utasítás végrehajtó rutinja.
C3	1. szegmens D7C5H Az EXOS 21 rutin segítségével beállítja a dátumot. A DATE Basic utasítás végrehajtó rutinja.
C4	1. szegmens CD2FH A 228H rendszerváltozó által meghatározott kezdőcímű puffer tartalmát B regiszter tartalmától függően kisbetűsíti (ha B=40H), vagy nagybetűsíti (ha B=60H). Gyakorlatilag az UCASE$ és LCASE$ Basic függvények végrehajtó rutinja.
C5	1. szegmens D812H Visszaállítja a funkcióbillentyű alapértelmezését. Az alapértelmezés szerinti funkciók megnevezésének táblázata az 1. szegmens D842H területen kezdődik.

A RST rutinok közül még egyet említünk itt meg. A RST 38H a megszakítás-kezelő rutinja. Programból kiiktatható ez a rutin, így valamelyest gyorsabb programfutás valósul meg. Ennek az az ára, hogy a géphez billentyűzetről a továbbiakban nem lehet hozzáférni. Aki tehát a RST 38H rutin belépési címét átírja POKE 56,201 segítségével, az számítson arra, hogy ha még a billentyűzetről bármit a program, a gép tudomására akar hozni, akkor előbb még a programból az eredeti tartalmat vissza kell állítania, vagy RESET-hez kell folyamodnia. Ennek a rutinnak a kiiktatása azzal is együtt jár, hogy a belső óra leáll.
A számítógép rendszerprogramjai, ill. az eddig ismertetett makrói tulajdonképpen egytől egyig a Basic nyelven írt programok értelmezését és végrehajtását teszik lehetővé. Amennyiben nem akarunk megelégedni a Basic utasítások és függvények Felhasználói kézikönyvben leírt lehetőségeivel, vagy ha egy-egy utasítást, vagy függvényt más célra akarunk felhasználni, akkor az eddig tárgyaltakat hasznosítva egy sor új lehetőséget kaphatunk. Természetesen a Basic mindig korlátokat jelent mind sebesség, mind pedig extra kívánságok teljesítése területén. Vannak feladatok, melyek csak gépi kódú program segítségével oldhatók meg.
A továbbiakban a számítógép utasításkészletét - többé kevésbé - ABC sorrendbe szedve tekintjük át, a számítógéphez adott Felhasználói kézikönyv felépítéséhez hasonlóan. A könyv ezen részében nem - vagy csak nagyon kivonatosan ismertetjük a kulcsszavak hatását, ill. az alkalmazásuk során követendő szintaktikai szabályokat. Célunk sokkal inkább az, hogy a nem kézenfekvő felhasználásra, vagy egy feladat, látvány, vagy sebesség szempontjából célszerűbb, vagy csak más megoldására példát adjunk.

2. Parancsok és utasítások

A program végrehajtása során az interpreter szépen sorba, egymás után hajtja végre az utasításokat. Amennyiben a programban nincs sorszám, hivatkozás, azaz nincs feltételhez kötött vezérlésátadás (GOTO), vagy nem hívunk meg szubrutint (GOSUB), akkor az interpreter végrehajtás közben nem is a sor elején lévő sorszámot, hanem az adott sor, ill. soron belül végrehajtott karakter, utasítás, adat memóriabeli címét használja fel a végrehajtáshoz. Így azután elképzelhető a 28. program, amit hibátlanul végre is hajt a számítógép.

88 ! azonos sorszamok, szoveg kogyozik
88 FOR I=0 TO 2*PI STEP PI/20
88   PRINT TAB(14+10*SIN(I)) "ENTERPRISE"
88 NEXT
88 RUN

Igaz, hogy nem lehet ilyen formában beírni, hiszen az azonos sorszámmal beírt programsorok közül csak az utoljára beírt érvényes, csak azt tárolja a számítógép. Amennyiben beírjuk a 29. programot és futtatjuk azt, akkor eredményként az előző programhoz hasonló listájú, működő programot kapunk.

0 FOR I=4827 TO 4880
0   PRINT I;PEEK(I)
0 NEXT
100 FOR I=4827 TO 4880
110   PRINT I;PEEK(I)
120 NEXT
140 ! elso sor eleje 0. programkent 4827 cimen van
150 POKE 4828,0
160 ! a masodik sor eleje 4827+sorhossz
170 POKE 4828+PEEK(4827),0
180 ! a harmadik sor eleje 4827+PEEK(4827)+PEEK(4827+PEEK(4827)) ! ez most 4865
190 POKE 4866,0
200 ! a cimek a program elejenek futtatasaval ellenorizhetok

Minthogy a memóriában lévő programba utólag POKE utasítással belenyúlunk, fontos, hogy a programba utólag beszúrt érték valóban oda kerüljön, ahová szántuk. Ezért első nekifutásra pontosan így írjuk be a számítógépbe a felülírni kívánt programot. Később majd keresünk olyan megoldást, amivel nem nekünk kell kiszámolni a felülírni kívánt memóriacímeket.

Már láttuk a rendszerváltozók esetében, hogy az IS-BASIC a gépi kódú program részére a memóriában az ALLOCATE utáni kifejezés értékének megfelelő byte-ot foglal le. Minthogy ez a helyfoglalás a Basic terület mozgatásával jár együtt az ALLOCATE mellékhatása a változók törlése is. Ezért az ALLOCATE 0, a program tetszőleges helyén az Enterprise Basic-ből hiányzó értékadás törlés végrehajtására is alkalmas. Adódhat programfutás közben olyan helyzet, hogy tömböket akarunk újra definiálni, ilyenkor végrehajthatunk egy ALLOCATE 0 utasítást. Győződjünk meg ennek hatásáról a 30. program segítségével.

100 ! ALLOCATE mint valtozok torlese
110 DIM C(10)
120 LET A=1:LET B=2 ! valtozok inicializalasa
130 PRINT A,B
140 ALLOCATE 0 ! CLEAR változó helyett
150 DIM C(10)
160 PRINT "c nevu tomb masodszor deklaralva"
170 PRINT A ! ez viszont nem megy, mar elfelejtette!

Az ALLOCATE hatása azonban többnyire csak a program futásának idejére érvényes. Legyünk óvatosak gépi kódú programjaink közvetlen meghívásával, mert ugyan a 31. program futása közben a Basic program a 10 byte-tal feljebb helyezkedik el a memóriában, mint az alapértelmezés esetében, de a program megszakítása, vagy befejezése után a program "visszacsúszik" az alapértelmezésű helyre. Így azután hiába próbálnánk a vélt helyről indítani a gépi kódú részt, az bizony a gép lemerevedéséhez vezethet.

1 PROGRAM "Allocate.bas"
100 ! ALLOCATE hatasa BASIC elejere
110 PRINT "BAsic eleje: ";PEEK(544)+256*PEEK(545)
120 ALLOCATE 10
130 PRINT "ALLOCATE 10 utan"
140 PRINT "BASIC eleje: ";PEEK(544)+256*PEEK(545)
150 CODE A=HEX$("1,2,3,4,5,6,7,8,9") ! proba kedveert
160 FOR I=4827 TO 4844 ! Memoria elejenek vizsgalata
170   PRINT I;PEEK(I) ! cim es tartalom
180 NEXT

Azt, hogy ez most így van, arról úgy győződhetünk meg a legegyszerűbben, hogy a 32. programot betöltjük 1. programként, akkor amikor a 31. programként él a gépben.

100 ! RUN-nal indits
110 ! 1-en futtatva ha a 31. pr. A 0.-on van
120 FOR I=4827 TO 4844 ! a 0. program tarolsasara szolgalo terulet vizsgalata
130   PRINT I;PEEK(I) ! cím es tartalom
140 NEXT

Futtassuk le még egyszer a 31. programot, ezután váltsunk programot, és RUN-nal indítsuk a 32. programot. A képernyőn megjelenő értékek mutatják, hogy a 0. programként beírt sorok "nyugalomban" visszacsúsznak a Basic terület elejére.

A függvény argumentumában megadott egyesekből és nullákból álló karaktersorozat decimális értékét adja. A függvény végrehajtó rutinja az 1. szegmens C42CH címen kezdődik. Van némi szépséghibája ennek a rutinnak. Elfogad maximum 12 karaktert, de kiértékelni ebből csak tízet képes. Így azután a BIN (111111111111) értékére a helyes 4095dec helyett, 4092 decimális értéket jelez ki a számítógép. Amennyiben 10 helyi értékűnél hosszabb bináris számot kell átalakítani decimálissá, akkor nekünk kell saját programot írni, például olyant, mint a 33. program.

1 PROGRAM "BIN-DEC.bas"
100 ! bin -> dec
110 INPUT PROMPT "Binaris ertek: ":B$
120 LET D=0 ! egyelore hibajelzesre segedvaltozo
130 LET H=LEN(B$) ! Binaris szam hossza
140 FOR I=1 TO H ! valoban csak 0 es 1 karaktereket tartalaz B$ ?
150   LET V$=B$(I:I) ! szeleteljuk le karakterenkent
160   IF V$<"0" OR V$>"1" THEN LET D=1 ! ha eltero karakter akkor hibajelzo beallitasa egyre
170 NEXT
180 IF D=0 THEN 210
190 PRINT "hibas karakter!"
200 GOTO 110
210 FOR I=H TO 1 STEP-1
220   LET D=D+VAL(B$(I:I))*2^(H-I) ! a decimalis erteknek megfeleloen ketto adott hatvanyaval valo szorzassal
230 NEXT
240 PRINT B$;" bin = ";D;" dec"

Hasonlóan szép feladat a tízes számrendszerbál binárisra átalakítani egy számot. Ezt elegáns rövid programmal elvégezhetjük, ha felhasználjuk a "bináris és" függvényt (34. program).

1 PROGRAM "DEC-BIN.bas"
100 ! dec -> bin
110 INPUT PROMPT "decimalis ertek: ":D$
120 LET H=0 ! hibajelzesre szolgalo valtozo
130 FOR V=1 TO LEN(D$)
140   LET V$=D$(V:V) ! karakter vizsgalatanak elokeszitese
150   IF V$<"0" OR V$>"9" THEN LET H=1 ! szamjegyre vizsgal
160 NEXT
170 IF H=1 THEN PRINT "hibas adat!":RUN ! nem szanjegzeket tartalmazo adat eseten ujraindul
180 LET D=VAL(D$)
190 IF D>2097151 THEN PRINT "a dec. szam tul nagy!"
200 PRINT D;" dec = ";
210 FOR I=20 TO 0 STEP-1
220   PRINT STR$((NOT(D BAND 2^I))+1); ! BAND felhasznalasaval binaris jegyeket hataroz meg
230 NEXT
240 PRINT " bin"

Érdemes egyszer a kettes számrendszert rajzolásra felhasználni (3. ábra).
Szinte filozófiai mélységek felismeréséhez vezet, ha a képernyőn egy szám egyenes mentén haladva, arra merőlegesen, a szám kettes számrendszerbeli alakjának megfelelően pontokat helyezünk el a 35. program segítségével.

1 PROGRAM "Bin.bas"
100 ! kettes szamrendszer minta rajza
110 GRAPHICS HIRES 16
120 SET INK WHITE
130 FOR I=0 TO 159
140   LET V=I
150   FOR B=7 TO 0 STEP-1 ! dec ertek binarisra alakitasa
160     LET E=INT(V/2^B) ! E 0 vagy 1 lehet
170     LET V=MOD(V,2^B) ! tovabbi vizsgalathoz erteket alaktit
180     IF E=0 THEN 240 ! 0 ertekre nem rajzol pontot
190     ! 1 erteknek megfelelo helyre pontot rajzol
200     PLOT I*8,344+B*8
210     PLOT I*8,340+B*8
220     PLOT I*8,340-B*8
230     PLOT I*8,336-B*8
240   NEXT
250 NEXT

A strukturált programozást az Enterprise a személyi számítógépek közül a legmagasabb fokon támogatja. Egy blokkra nevével hivatkozhatunk meghívásnál, listázásnál, törlésnél, átsorszámozásnál. A blokkok nagyfokú önállósága mellett azok szervesen épülnek a programba. Szabályos szerkezetüket az interpreter ellenőrzi.
A programozási gyakorlatban - ebben az összeállításban is - lépten-nyomon felhasználjuk a CALL utasítást egy-egy függvény (blokk) hívására, de azt, hogy egy függvény önmagát hívja, arra nem szoktunk gondolni. Az önmagát hívó szubrutinokkal, függvényekkel óvatosan kell bánni! Elvetemült programozó (?) pillanatok alatt kiakaszthatja a számítógépet pl. a

10 DEF Y(x)=2*Y(x)
20 PRINT Y(1)

programmal. Csak a RESET segít, de az összes létező és szerencsére nem ismert hibaüzenet a képernyőre kerülhet (pl. INTERNAL CHEKSUM ERROR). De miért ne próbálkozhatnánk az önmagát hívó programkészletekkel. Azokat a programozási fogásokat, melyek során valamely eljárás (függvény, blokk) önmagát hívja, rekurziónak nevezik. Az ismételt meghívás során egyre "mélyebbre" kerülünk a programban, de az eljárás végén, a visszatéréskor, az adott mélységből a programfutás még mindig az eljáráson belül, de eggyel kisebb mélységben folytatódik.
A rekurzív feladatmegoldás során a bonyolult feladatot a legegyszerűbb alapállapot megkeresésével és annak megoldásával kezdjük. Innen a probléma kezdeti megfogalmazásából és megoldásából azután megoldhatók az összetett, bonyolult, de az "őseredetre" visszavezethető problémák. A rekurzióval megoldható feladatok iskolapéldái közül vegyünk sorra néhányat: A 4. ábra a bináris fát mutatja. A fa ágai a program szerint egy csomópontból jobbra-balra 45 foka indulnak és minden ág végén újabb elágazás következik az előző szabály szerint. Ez az elágaztatás a végtelenségig folytatható lenne, valahol gátat kell szabni a rajzolásnak

A program valahol az élet rendjének kissé ellentmond, hiszen a fa valahonnan egy törzsből (szimmetrikusan) fejlődik, ágazik szét. A mi rekurzív programunk elindul a törzsből és mindig a balra ágazó útvonalon gyorsan megkeresi a fa egyik ágának hegyét és onnan visszafelé kiépíti a törzshöz visszavezető ágakat. Ezt a rekurzív megoldást mi magunk is kipróbálhatjuk a 36. program futtatásával.

1 PROGRAM "Bin_fa.bas"
100 ! rekurziv binaris fa
110 GRAPHICS 4
120 OPTION ANGLE DEGREES
130 SET INK WHITE
140 PLOT ANGLE 90
150 LET X=640:LET Y=0
160 LET L=300:! faag kezdeti hossza
170 LET A=.6 ! rovidulesi tenyezo az elagazasok utani vonalhoz
180 PLOT X,Y; ! kezdopont kijelolese
190 CALL FA(L)
200 END
210 DEF FA(L)
220   IF L<10 THEN EXIT DEF ! kilep az adott meghivasi melysegbol ha a fa aga rovidebb mint a hatarertek
230   PLOT FORWARD L;
240   PLOT LEFT 45;
250   CALL FA(L*A) ! a rovidulesi tenyezonek megfelelo hosszal meghivja onmagat
260   PLOT RIGHT 90;
270   CALL FA(L*A)
280   PLOT LEFT 45;
290   PLOT BACK L ! visszaallas az elagazasra
300 END DEF

Érdemes összehasonlítani a rekurzió nélküli, bináris fát felrajzoló programot (37. program) az előzővel.

100 REM binaris fa
110 GRAPHICS
120 SET INK WHITE
130 OPTION ANGLE DEGREES
140 LET N=7:LET H=400
150 LET S=60 ! elagazas szoge
160 LET F=.6 ! rovidulesi aranyszam ,
170 LET N1=2^(N-1)
180 ! csomopontok koordinatainak, az indulo agak hajlasszogenek tarolasahoz tomb kijelolese
190 DIM X(N,N1),Y(N,N1),W(N,N1)
200 LET X(0,0)=600:LET Y(0,0)=0
210 LET X(1,1)=600LET Y(1,1)=300
220 LET W(1,1)=90:LET K=1
230 PLOT X(0,0),Y(0,0);X(1,1),Y(1,1) ! az elso ag kirajzolasa
240 FOR L=2 TO N ! az egyes szintek kivalasztasa
250   LET H=H*F: LET K=K*2 ! ezen a szinten ilyen hosszu es ennyi agat kell rajzolni
260   FOR J=1 TO K STEP 2 ! mert az agak fele jobbra, fele balra indul
270     LET KK=INT(J/2)+1
280     LET W(L,J)=W(L-1,KK)+S: LET Z=W(L,J) ! balra elagazas
290     LET X(L,J)=X(L-1,KK)+H*COS(Z) ! az ag vegpontjanak x koordinataja
300     LET Y(L,J)=Y(L-1,KK)+H*SIN(Z) !az ag vegpontjanak y koordinataja
310     PLOT X(L-I,KK),Y(L-I,KK);X(L,J),Y(L,J) ! a balra elagazo ag rajza
320     LET W(L,J+1)=W(L-1,KK)-S: LET Z=W(L,J+1) ! jobbra elagazas
330     LET X(L,J+1)=X(L-1,KK)+H*COS(Z)
340     LET Y(L,J+1)=Y(L-1,KK)+H*SIN(Z)
350     PLOT X(L-I,KK),Y(L-I,KK);X(L,J+1),Y(L,J+1) ! a jobbra elagazo vonal rajza
360   NEXT
370 NEXT

Ennél a programnál rendre kiszámítjuk a faágak kezdő- és végpontjainak koordinátáit, a számítás eredményeit tömbváltozóként tároljuk, majd a kiszámított koordináták közé megrajzoljuk az egyenes szakaszokat. A program szemmel láthatóan is hosszabb, de ha a tömbök miatt lefoglalt memóriaigényt is figyelembe vesszük, akkor a rekurzív program előnye, memóriatakarékossága vitathatatlan.
David Hilbert leírt egy módszert, mellyel egy véges négyzet alakú síkfelület végtelen hosszúságú törtvonallal kitölthető. Egy ilyen görbét mutat az 5. ábra.

A Hilbert-görbéket vizsgálva a következőket deríthetjük ki: A 2. rendű görbe 4 db 1. rendű görbéből áll, amelyeket 3 "híd" köt össze. Hasonlóan a 3. rendű görbe 4 db 2. rendű görbéből áll, 3 összekötő híddal stb. Sajnos az N. rendű görbét felépítő 4 db N-1. rendű görbe körüljárási iránya nem egyezik meg, ezt különböző paritásnak nevezik. A teknős grafika számára a következő algoritmust írhatjuk elő:

1. Fordulj 90°-ot balra
2. Rajzold meg az N-1. rendű görbét S oldalhosszúsággal és 1 paritással
3. Menj S lépést előre (1. híd)
4. Fordulj 90°-ot jobbra
5. Rajzold meg az N-1. rendű görbét S oldalhosszúsággal és -1 paritással
6. Menj előre S lépést (2. híd)
7. Rajzold meg az N-1. rendű görbét S oldalhosszúsággal és -1 paritással
8. Fordulj 90°-ot jobbra
9. Menj előre S lépést (3. híd)
10. Rajzold meg az N-1. rendű görbét S oldalhosszúsággal és 1 paritással
11. Fordulj 90°-ot balra

Az algoritmus alapján megírhatjuk a 38. programot, mely a rekurzió elemeit mutatja, de legalább áttekinthető.

100 REM Hilbert gorbe
110 LET N=6:LET H=640:LET X0=960:LET Y0=320
120 FOR I=1 TO N
130   LET H=H/2
140   LET X0=X0+INT(H/2):LET Y0=Y0+INT(H/2)
150   LET X=X0-320:LET Y=Y0 ! indulasí feltetelek
160   GRAPHICS
170   SET INK WHITE
180   PLOT X, Y;
190   CALL A(I)
200   IF INKEY$="" THEN GOTO 200 ! a kovetkezo szintu Hilbert gorbe megrajzolasa billentyunyomasra indul
210 NEXT
220 END
230 DEF A(I)
240   IF I>0 THEN ! tovabbi hivasok a feltetel szerint
250     CALL D(I-1):LET X=X-H:PLOT X,Y; ! jobbra
260     CALL A(I-1):LET Y=Y-H:PLOT X,Y; ! lefele
270     CALL A(I-I):LET X=X+H:PLOT X,Y; ! balra
280     CALL B(I-1)
290   END IF
300 END DEF
310 DEF B(I)
320   IF I >0 THEN
330     CALL C(I-1):LET Y=Y+H:PLOT X,Y; ! felfele
340     CALL B(I-1):LET X=X+H:PLOT X,Y;
350     CALL B(I-1):LET Y=Y-H:PLOT X,Y;
360     CALL A(I-1)
370   END IF
380 END DEF
390 DEF C(I)
400   IF I>0 THEN
410     CALL B(I-1):LET X=X+H:PLOT X,Y;
420     CALL C(I-1):LET Y=Y+H:PLOT X,Y;
430     CALL C(I-1):LET X=X-H:PLOT X,Y;
440     CALL D(I-1)
450   END IF
460 END DEF
470 DEF D(I)
480   IF I >0 THEN
490     CALL A(I-1):LET Y=Y-H:PLOT X,Y; ! balra
500     CALL D(I-1):LET X=X-H:PLOT X,Y; ! lefele
510     CALL D(I-1):LET Y=Y+H:PLOT X,Y; ! jobbra
520     CALL C( I-1 )
530   END IF
540 END DEF

A teljes rekurzióval megírt programot a 39. program mutatja.

1 PROGRAM "Hilbert.bas"
100 ! HILBERT gorbe teljes rekurzioval
110 GRAPHICS
120 OPTION ANGLE DEGREES
130 SET INK WHITE
140 LET X=940:LET Y=700:LET P=1 ! paritas
150 PLOT X,Y,ANGLE 180;
160 LET N=5 ! 6>=n>=1 a gorbe "rendje"
170 LET S=10*2^(6-N) ! oldalhossz
180 CALL HILBERT(S,N,P) ! jellemzok: oldalhossz, renduseg, paritas
190 END
200 DEF HILBERT(S,N,P)
210   IF N=0 THEN EXIT DEF
220   PLOT LEFT 90*P; ! paritastol fuggoen balra vagy jobbra
230   CALL HILBERT(S,N-1,-P) ! sajat magat meghivja
240   PLOT FORWARD S;RIGHT 90*P;
250   CALL HILBERT(S,N-1,P)
260   PLOT FORWARD S; ! osszekotes
270   CALL HILBERT(S,N-1,P)
280   PLOT RIGHT 90*P;FORWARD S;
290   CALL HILBERT(S,N-1,-P)
300   PLOT LEFT 90*P;
310 END DEF

Ez már kevésbé tekinthető át. A 210. soron lévő megszakítási feltétel biztosítja, hogy a program az N. szintről az N+1. szintre térjen vissza a meghívások sorozatában.

Egy másik, a számítógépes grafika által kedvelt görbe, a Koch-görbe (6. ábra).
Rajzoljunk egy szabályos háromszöget! Osszuk három egyenlő részre minden oldalát. Rajzoljunk a középső harmadra kifelé egy újabb szabályos háromszöget, majd radírozzuk ki a középső harmadot. Az így keletkezett alakzat minden egyes szakaszára ismételjük meg az eljárást, tetszőlegesen sokszor. Ezután az alakzat rendjének nevezzük azt a számot, ahányszor az adott görbét előállító algoritmust megismételjük.
Vegyük szemügyre az ábrát! A teknős grafika a következő utasításokra rajzolja meg a hópehely görbe valamely oldalának soron következő szakaszát:

1. Menj S/3 lépést előre
2. Fordulj 60°-ot balra
3. Menj S/3 lépést előre
4. Fordulj 120°-ot jobbra
5. Menj S/3 lépést előre
6. Fordulj 60°-ot balra
7. Menj S/3 lépést előre

Ebből már elkészíthetjük a rekurzív - önmagát különböző paraméterekkel hívó programrészletet.
A Koch-görbét a 40. programmal rajzolhatjuk meg.

1 PROGRAM "Koch.bas"
100 ! KOCH gorbe
110 GRAPHICS
120 OPTION ANGLE DEGREES
130 SET INK WHITE
140 LET X=980:LET Y=360
150 PLOT X,Y;:PLOT ANGLE 210;
160 FOR I=1 TO 3 ! egyenlooldalu haromszogre epit
170   LET S=700 ! a kiindulasi oldalhossz
180   LET N=3
190   CALL KOCH(S,N)
200   PLOT RIGHT 120;
210 NEXT
220 END
230 DEF KOCH(S,N) ! az eljaras valtozoi
240   IF N=0 THEN PLOT FORWARD S;:EXIT DEF
250   CALL KOCH(S/3,N-1) ! oldal mindig harmada a korabbinak
260   PLOT LEFT 60; ! balra
270   CALL KOCH(S/3,N-1)
280   PLOT RIGHT 120; !jobbra
290   CALL KOCH(S/3,N-1)
300   PLOT LEFT 60; ! balra
310   CALL KOCH(S/3,N-1)
320 END DEF

Amennyiben a KOCH(S,N) eljárást a 41. program szerint megváltoztatjuk, hasonló logikájú, de egészen más megjelenésű képet kapunk (7. ábra)

1 PROGRAM "Koch2.bas"
100 ! kiforditott KOCH gorbe
110 GRAPHICS
120 OPTION ANGLE DEGREES
130 SET INK WHITE
140 LET X=1000:LET Y=20 ! indulasi pont
150 PLOT X,Y;:PLOT ANGLE 180;
160 FOR I=1 TO 3 ! egyenlooldalu haromszogre epit
170   LET S=810 ! a kiindulasi oldalhossz
180   LET N=3 ! 1<= N <=4
190   CALL KOCH(S,N)
200   PLOT RIGHT 120;
210 NEXT
220 PLOT 1000,20:PLOT 0,0,PAINT
230 END
240 DEF KOCH(S,N) ! az eljaras valtozoi: oldalhossz, a gorbe rendje
250   IF N=0 THEN PLOT FORWARD S;:EXIT DEF ! az eljaras adott melysegebol valo visszateres feltetele
260   CALL KOCH(S/3,N-1)
270   PLOT RIGHT 60; ! jobbra
280   CALL KOCH(S/3,N-1)
290   PLOT LEFT 120; ! balra
300   CALL KOCH(S/3,N-1)
310   PLOT RIGHT 60; ! jobbra
320   CALL KOCH(S/3,N-1)
330 END DEF

Az Enterprise által megjeleníthető színgazdagságnak a televízió szab korlátokat. Számítógépünk egyidejűleg 256 színt tud a képernyőre küldeni. Az egyidejűleg megjeleníthető színszám a GRAPHICS-módtól függ. A színek kijelölésére több lehetőség is kínálkozik. Az RGB viszont csak a 256 színű üzemmódban adja a helyes színárnyalatokat.
Nézzünk egy-két színes lehetőséget! A színkeverés szabályait mutatjuk be a 42. program segítségével.

1 PROGRAM "Szinkor.bas"
100 ! szinkor
110 GRAPHICS HIRES 256
120 SET INK RGB(1,0,0) ! piros
130 PLOT 510,240,ELLIPSE 240,240,PAINT
140 SET INK RGB(0,1,0) ! zold
150 PLOT 770,240,ELLIPSE 240,240,PAINT
160 SET INK RGB(1,1,0) ! sarga
170 PLOT 640,200,PAINT
180 SET INK RGB(0,0,1) ! kek
190 PLOT 640,470,ELLIPSE 240,240,PAINT
200 SET INK RGB(0,1,1) ! cyan
210 PLOT 760,350,PAINT
220 SET INK RGB(1,0,1) ! lila
230 PLOT 500,350,PAINT
240 SET INK RGB(1,1,1) ! feher
250 PLOT 640,250,PAINT

Nyomtatóra is kiküldhetjük az ábrát, igaz itt inkább csak árnyalatokat tudunk megkülönböztetni (8. ábra). Idővel majd csak felnőnek a nyomtatók lehetőségei a számítógépekéhez, áruk pedig leszáll azokéhoz. A 43. program egyelőre csak a szivárvány félköreit rajzolja meg, de nyitóképnek, hangulatteremtőnek és a színek bemutatására jó lehetőséget kínál.

1 PROGRAM "Sziv1.bas"
100 ! Szivarvany
110 GRAPHICS HIRES 256
120 LET N=640:GOSUB 180 ! felso burkolovonal rajzolasa
130 FOR N=600 TO 340 STEP-40 ! tovabbi szivarvanyivek rajzolasa
140   GOSUB 180
150   PLOT 640,20+N,PAINT ! szivarvany beszinezese
160 NEXT
170 END
180 READ R,G,B
190 SET INK RGB(R,G,B)
200 PLOT 640,0;ELLIPSE N,N ! a kepernyo szelen hiba nelkul felkorivet rajzol
210 RETURN
220 DATA 1,0,0,1,0,0,1,.5,0,1,1,0,0,1,0,0,1,.5,0,1,1,1,0,1

100 PROGRAM "Sziv2.bas"
110 ! Szivarvany finomabb felbontassal
120 GRAPHICS HIRES 16
130 SET PALETTE RGB(1,0,0),RGB(1,.5,0),RGB(1,1,0),RGB(0,1,0),RGB(0,0,1),RGB(0,0,.5),RGB(1,0,1),0
140 LET SZIN=1
150 FOR N=640 TO 340 STEP-40
160   SET INK SZIN:LET SZIN=SZIN+1
170   PLOT 640,0;ELLIPSE N,N
180   IF N<640 THEN PLOT 640,N+10,PAINT
190 NEXT

Mind a 256 színt a képernyőre csalhatjuk a 44. programmal.

1 PROGRAM "256szin.bas"
100 ! 256 szin a kepernyon
110 GRAPHICS 256
120 LET SZIN=0
130 FOR V=0 TO 1200 STEP 80
140   FOR F=0 TO 700 STEP 44
150     SET INK SZIN
160     FOR X=0 TO 73 STEP 8
170       PLOT V+X,F;V+X,F+43 ! szines teglalap rajza
180     NEXT
190     LET SZIN=SZIN+1
200   NEXT
210 NEXT

Itt szép szabályosan sorakoznak a színes felületek, de a 4 5. program a kaleidoszkóp véletlenszerű színkavalkádját biztosítja.

1 PROGRAM "Kaleid1.bas"
100 ! Klaeidoszkop
110 GRAPHICS HIRES 256
120 RANDOMIZE
130 SET LINE MODE 3
140 FOR V=0 TO 1279 STEP 80
150   SET INK RND(255) ! veletlen szin kivalasztasa
160   PLOT 0,0;V,719 ! vonal bal also sarokbol
170   SET INK RND(255)
180   PLOT 1279,0;V,719 ! vonal jobb also sarokbol
190   SET INK RND(255)
200   PLOT 0,719;V,0 ! vonal bal felso sarokbol
210   SET INK RND(255)
220   PLOT 1279,719;V,0 ! vonal jobb also sarokbol
230 NEXT

1 PROGRAM "Kaleid2.bas"
100 GRAPHICS HIRES 256
110 SET VIDEO COLOUR 3
120 RANDOMIZE
130 FOR N=1 TO 300
140   LET X=RND(600):LET Y=RND(300)
150   SET INK RND(255) ! veletlen szam kivalasztas
160   FOR F=0 TO 8 STEP 4 ! vizszintes, fuggoleges pontmeret aranzainak korrigalasa
170     PLOT 640+X,310+Y+F ! kozeppontos szimetria biztositasa
180     PLOT 640-X,310+Y+F
190     PLOT 640-X,310-Y-F
200     PLOT 640+X,310-Y-F
210   NEXT
220 NEXT
230 IF INKEY$="" THEN 230
240 RUN 100

A képernyő vagy annak egy-egy adott színű felülete a másodperc tört része alatt átszínezhető oly módon, hogy a szín PALETTE adott sorszámú színelemének új értéket adunk. Megtehetjük ezt a szín átdefiniálást a paletta több színével is. Ha az egymás mellett lévő felületeket úgy színezzük át, hogy azok mindig a tőlük jobbra (balra) levő színét veszik fel, akkor már három szín alkalmazása esetén is fényfüzért, fénypontok folyamatos mozgásának élményét idézhetjük fel a kép előtt ülőben. A 46. program a képre írt szöveg körül körbe forgó fénykeretet mozgat, forgat.

1 PROGRAM "Keret.bas"
100 ! keret-porgetes
110 NUMERIC D(3),A
120 LET D(0)=10:LET D(1)=20:LET D(2)=30
130 CALL KERET
140 PLOT 360,356,
150 PRINT £101:" FELIRAT "
160 SET INK 1
170 PLOT 360,356,
180 PRINT £101:"* *"
190 CALL FOROG
200 GOTO 190
210 DEF KERET
220   GRAPHICS HIRES 16
230   SET PALETTE 0,255,0,0,0,10,20,30
240   LET C$=CHR$(159) ! a keretet alkoto idom (lehetne csillag,kor is)
250   FOR N=5 TO 7
260     SET INK N
270     FOR I=-5 TO 9 STEP 3
280       PLOT 100+72*(I+N),200,
290       PRINT £101:C$
300       PLOT 1108-72*(I+N),520,
310       PRINT £101:C$
320     NEXT
330     PLOT 100,280+80*(7-N)
340     PRINT £101:C$
350     PLOT 1108,280+80*(N-5)
360     PRINT £101:C$
370   NEXT
380 END DEF
390 DEF FOROG
400   LET A=D(0) ! a keretet alkoto negyzetek szineinek tovabbleptetese a palettan
410   LET D(0)=D(1):SET COLOR 5,D(0)
420   LET D(1)=D(2):SET COLOR 6,D(1)
430   LET D(2)=A:SET COLOR 7,D(2)
440 END DEF

Az utasítás lehetőségei a forrás és célcsatorna kijelölésével sokrétűen variálhatók. Legáltalánosabban - alapértelmezésként - használható az editor csatorna nyomtatóra való kiküldése, kimásolása. A grafikus képernyő tartalmának kinyomtatására a német verziójú Enterprise gépeknél a VDUMP biztosít lehetőséget. A VDUMP végrehajtó rutinja a 4. szegmens F6974 kezdődik. Ez a hardcopy rutin még a színhatásokat is visszaadja, igaz ezt a vonaltípusok megválasztásával biztosítja. A demo kazetta ábráját a 9. ábrának megfelelően adja vissza a nyomtatón.

A hardcopy rutint mi magunk is megírhatjuk, erre több lehetőség is kínálkozik. A program letapogatja a képernyőt a LOOK utasítás felhasználásával. A képernyőn lévő információt át kell alakítani a nyomtató által grafikus karakter nyomtatását lehetővé tevő adatsorrá.
Nézzük meg, milyen adatokból képes grafikus jelet nyomtatni az Enterprise számítógéphez minden külön interface nélkül kapcsolható EPSON nyomtató. Először is a 10. ábra alapján - ahol a csatlakozókat a készülék háta felől nézve ábrázoltuk - el kell készíteni a csatlakozó zsinórt. Az alkatrészigény igen szerény.

A nyomtatóhoz, vagy a Centronics interface-hez amphenol, a számítógéphez 2,54 mm osztástávolságú élcsatlakozó kell. Az összekötő kábel 12 eres (az sem lenne rossz, ha árnyékolt lenne, de rövid összekötő zsinórnál ez nem létfontosságú). A nyomtató vezérléséhez, működéséhez nélkülözhetetlen a nyomtató néhány fontos vezérlő parancsának ismerete:

A hardcopyhoz ezek közül a soremelés nagyságának beállítását kell először tisztázni, hiszen ahogy a képernyőn, itt is összefüggő képpont-sort kell kapnunk. Az összefüggő képet, a 8/72 inches soremelés beállításával biztosíthatjuk.
Egy sorban a grafikus üzemmódtól függően n független képpont-oszlop különíthető el. Hogy hány képpont-oszlopot akarunk kinyomtatni, azt a képpont-nyomtatás módját kijelölő "K" parancs segítségével adhatjuk meg.
A képernyőről letapogatott információkat úgy kell átadni a nyomtatónak, hogy az a vett adatbyte-ot egy képpont-oszlop (8 függőlegesen elhelyezkedő képpont) nyomtatási képeként értelmezhesse. A képpont-oszlop egyes képpontjait az adatbyte egyes értékeinek megfelelően: nyomtatja, ha a hozzárendelt bit 1 értékű, üresen hagyja, ha a hozzárendelt bit 0 értékű.
A hozzárendelési szabály: legmagasabb helyi értékű bit - legfelső képpont stb. Egy adott képpont-oszlopot meghatározó, adatbyte-ot a következőképpen kell képezni:

ahol ki=1, ha az i. pont nyomtatandó; ki=0, ha az i. üresen hagyandó. Ennyi ismeret birtokában megírhatjuk a saját hardcopy programunkat.

100 ! HARDCOPY EPSON RX-80 ra
110 ! elobb demo 4 be pr szam valtas!
120 LPRINT CHR$(27);"A";CHR$(8) ! soremelest 8/72"-ra beallit
130 FOR Y=610 TO 48 STEP-32 ! a kepernyon a figurak ezen a teruleten vannak
140   LPRINT CHR$(27);"K";CHR$(64);CHR$(1);
145   ! egy osszefuggo sor 320=1*256+64 pont szeles a nyomtaton
150   FOR X=0 TO 319 ! letapogatjuk a kepernyot vizszintesen
160     LET K,P=0
170     FOR F=Y TO Y+31 STEP 4 ! a nyomtathato karakter magassaga 8 pixel
180       LOOK AT X*4,F:R ! R a kepelem papir- vagy attol eltero szinu
190       LET V=-(NOT(R)) ! V=0 ha a pont papirszinu
200       LET P=P+V*2^K:LET K=K+1 ! egy grafikus karakter oszlop osszeallitasa
210     NEXT
220     LPRINT CHR$(P); ! pufferbe gyujti a grafikus karaktereket
230   NEXT
240   LPRINT CHR$(13)
245   ! ha osszejott a 320 karakter akkor kinyomtatja, es sort emel
250 NEXT
260 END

A 47. programot írjuk be n. programként a számítógép memóriájába. Ha az itt közölt - a DEMO kazetta negyedik részéről ismert - 11. ábrát ki akarjuk nyomtatni, akkor a 0. programként töltsük be a DEMO programot. Futtassuk azt le, majd amikor az ábra már a képernyőn van STOP-pal állítsuk le ezt a programot. CHAIN n-nel indítsuk el a korábban beírt hardcopy programunkat. Bizony az ilyen BASIC nyelven írt program igen hosszú idő alatt készíti el a másolatot.

Az x, y ciklusváltozók kezdő- és végértékének megváltoztatásával természetesen a képernyő bármelyik területéről készíthetünk másolatot. Vigyáznunk kell, hogy a "K" parancs utáni egy sorba nyomtatni kívánt karakterszám beállítást összhangba hozzuk az x ciklusváltozó kezdő- és végértékével!
A képen látott ábra a számítógép memóriájában is megtalálható. A rajz pontjait és szín információit a számítógép a grafikus üzemmód jellegétől függően tárolja. A tárolás módja az Enterprise memóriagazdálkodásától megszokott módon összevissza történik. Ez az összevisszaság persze igen korrekt logika alapján rendszerbe van foglalva. Mindenesetre, a 48. program használata a bekapcsolás utáni alapállapotú gép esetére igaz.

100 ! hardcopy memoriabol elso 125 sor
110 GRAPHICS ATTRIBUTE
120 CALL DEMO
130 LPRINT CHR$(27);"A";CHR$(1) ! pixelsoronkent nyomtatunk, a soremeles 1/72"
140 TIME "00:00:00" ! nyomtatasi ido meresehez ido nullazas
150 CALL HARDCOPY
160 PRINT TIME$
170 END
180 DEF HARDCOPY
190   FOR F=0 TO 125 ! a DEMO csak a kepernyo felso reszet foglalja el
200     LPRINT CHR$(27);"K";CHR$(64);CHR$(1); ! egy sorba 320 kepernyopontot nyorntatunk
210     FOR V=0 TO 39
220       LET K=SPEEK(254,11308+F*40+V)
225       ! memoriabol kiolvassuk a grafikus kepernyo tartalom egy byte-jat
230       FOR I=7 TO 0 STEP-1 ! leszeleteli a kepernyomemoria egy byte-jat
240         LPRINT CHR$(-1*((K BAND 2^I)=2^I)); ! a bitterkepbol 0 vagy 1 megallapitasa
250       NEXT
260     NEXT
270     LPRINT CHR$(13)
275     ! a pufferbe gyujtott 320 grafikus nyomtatasi karaktert kikuldi, es sort emel
280   NEXT
290 END DEF
300 DEF DEMO
310   FOR R=10 TO 300 STEP 20
320     PLOT 640,340,ELLIPSE 2*R,R
330   NEXT
340   PLOT 100,600,ELLIPSE 80,80,PAINT
350   PLOT PAINT 200,715;1279,715
360 END DEF

Aki több videocsatornát nyit meg és azok részeit helyezi a képernyőre, annak azért erősen módosítania kell az itt közölt programot. Az alapértelmezésű gépben a grafika memóriaterülete a 254. és 255. szegmensen helyezkedik el. A kép egy része 5705 byte a 254. szegmensen, míg a további 9328 byte információ a 255. szegmensen található.

A karakterek közül nagyon sok vihető billentyűzetről a képernyőre. Vannak azonban képernyőn megjeleníthető karakterek, és nem látható, ún. vezérlőkarakterek, melyek csak CHR$(n) segítségével érhetők el. A TEXT üzemmódban értelmezhető karakterek táblázatát a következ6kben tekinthetjük át:

A számítógép igen optimista naptárral rendelkezik. A naptári dátumot egészen 2079 december 31-ig képes követni. (Jó lesz, ha időben lecseréljük a számítógépünket!) A beírt dátumot a hónap-nap egyeztetést az 1. szegmens E502H-E513H táblázat segítségével végzi el. Elegánsan kezeli a szökőévek februárjait is. Bekapcsoláskor ugyan egy kicsit félszeg módon 1980 nulladik hónapjának nulladikát írja ki, de ilyen zagyvaságot tőlünk nem fogad el.
A DATE$ mellett kiolvashatjuk a naptári adatokat a BF75H-BF77H memóriacímekről is.

• A BF77H 49015dec az 1980 óta eltelt évek számát tartalmazza.
• BF76H 49014 címről a hónap míg a
• BF7SH 49013 címről a nap olvasható ki.

A memóriacímek tartalma BCD-ben van. Innen adódik, hogy az egy byte-on ábrázolható legnagyobb szám 99dec. Most már megérthetjük; hogy miért "csak" 2079-ig használható a naptárunk.
1980+99 = 2079

A nagy tömegű adattal - igen sok változóval - dolgozó programok indexes változókat, tömbváltozókat (ki melyik elnevezést szereti jobban) igényelnek. Ezt a sok adatot előre kijelölt tömbökben (vektor, vagy mátrix) tárolhatjuk.
Kezdjük a kijelöléssel! Más számítógép típusoktól eltérően erre a célra a DIM mellett a NUMERIC és a STRING utasítás is rendelkezésünkre áll. A tömbök deklarálása kapcsán számítógépünknek több sajátossága (furcsasága?) van. A
10 DIM A(10)
20 DIM A(10)
utasítássor a kétszeres inicializálás hibával áll le. A
10 FOR I=1 TO 2
20 DIM A(10)
...
...
50 NEXT
programrészlet szintaktikai hibához vezet, ez egyébként a skatulyázás jelzőbyte 7. bitjének állapotával hozható összefüggésbe, ahová a rendszer inicializálás jelzést helyez el a ciklus előszöri lefutása során a DIM-et tartalmazó programsor feldolgozásakor.
Vigyázni kell, mert azonos nevű tömbváltozó és változó alkalmazása is hasonló hibákhoz vezet, mint előbb és a hibajelzés is attól függ, hogy milyen sorrendben fordul elő a két azonos betűjel (név) használata:
10 DIM A (10)
20 LET A=10
vagy
10 LET A=10
20 DIM A(10)

A karakteres változó esetében is hasonló helyzet áll fent, mint a numerikus változók névhasználata között, de megengedett az A$="SAMU" értékadás mellett az azonos betű (név) használata egy numerikus tömbhöz, pl. DIM A(5) alakban egy programon belül. A karakter, ill. számváltozók tárolásánál láttuk azok helyigényét. A stringeket tartalmazó tömbök alapértelmezés szerint 132 karakter hosszúak lehetnek. Erre az esetre foglal le helyet a megfelelő RST 10 rutin. Ez azonban azt is jelenti, hogy igen hamar kimeríthetjük az Enterprise 128-as bejelentkezéskor kiírt 114858 byte méretű memóriáját. Vigyázat ez így félreértésre ad okot!
Az Enterprise memória gazdálkodás zseniális, de a Z80 processzor által csak 65535-ig címezhetünk. Basic-ben a 0. program számára maximálisan 44259 byte áll rendelkezésre, a 0-tól eltérő sorszámú program részére pedig 32702 byte használható fel. Ez a 0. program részére biztosított több mint 43 kbyte nagyon hamar kimerülhet, ha a karakteres tömbváltozók részére csak úgy DIM S$(n) utasítással foglalunk helyet. Ilyenkor már a 10 DIM S$(329) egysoros program elindítása után is "kevés a memória" hibajelzést kapunk, márpedig egy tűrhető méretű adatkezelő programban is pár száz adatpárt kívánunk tárolni. Ilyen esetben - de általában mindig - célszerű csak a várható maximális hosszúságú stringnek megfelelő méretű tömböt lefoglalni.
Az IS-BASIC sajátossága, hogy a tömbtik legfeljebb két dimenziósok lehetnek. Más gépeknél mód van a három dimenziós (vagy akár, a hétköznapi gondolkozással nehezen értelmezhető hat dimenziós) tér pont koordinátáinak egy tömbben való tárolására a P (X,Y,Z) alakban. Nekünk ott az X (N), Y (N), Z (N) alakot célszerű alkalmazni, de a sík pontjainak leírásánál lehetőségünk van a P (X,Y) alakú adattárolásra.
A sík pontjainak tárolására egy speciális lehetőség a képernyőtartalom tömbben való tárolása. Így mintegy a képernyőn látható kép "tükörképét" is tárolhatjuk egy tömbben. Esetenként könnyebb ebben a tömbben elvégezni a vizsgálatot, mint a képernyőn, ill. a képernyő memóriában. Erre a lehetőségre ad példát a 49. program a DEMO kazettán is megtalálható bombázó játék egy másik megvalósításával.

100 PROGRAM "Bombazo.bas"
110 ! Bombazo jatek
120 TEXT 40
130 SET STATUS OFF
135 SET £102:PALETTE 0,CYAN,0,BLUE
140 SET CHARACTER 159,126,126,90,90,126,126,126,126,126
150 DIM W(25,38)
160 LET R=0:LET T$=""
170 LET R$=" >-+":LET H$=CHR$(159)
180 LET B$="*"
190 LET P=0:LET T$="":PRINT AT 10,15:"Kis turelmet!"
200 CALL VAROS
210 FOR F=2 TO 23
220   FOR V=0 TO 34
230     PRINT £102,AT 1,1:"pont=";P
240     IF W(F,V+3)=1 THEN 610 ! utkozot, vege a jateknak
250     PRINT £102,AT F,V:R$
260     IF T$=" " THEN 310
270     FOR T=1 TO 50
280     NEXT
290     LET T$=INKEY$ ! bomba kioldasahoz szokoz billentyuvel
300     IF T$=" " THEN LET X=V+2:LET Y=F
310     IF T$=" " THEN CALL BONT
320   NEXT
330   PRINT £102,AT F,V:" "
340 NEXT
350 GOTO 200
360 DEF BONT
370   PRINT £102,AT Y,X:" "
380   PRINT £102,AT Y+1,X:B$
390   IF Y=22 THEN PRINT £102,AT Y+1,X:" ":LET W(Y+1,X)=0:LET T$=""
400   IF W(Y,X)=1 THEN LET P=P+1:LET W(Y,X)=0
410   LET D$=INKEY$:LET Y=Y+1
420 END DEF
430 DEF VAROS
440   FOR V=1 TO 38
450     FOR F=1 TO 25
460       LET W(F,V)=0
470     NEXT
480   NEXT
490   CLEAR SCREEN
500   PRINT  102,AT 1,20:"Rekord=";R
510   RANDOMIZE
520   PRINT £102,AT 24,2:"=====================================";
530   FOR V=7 TO 33
540     LET M=RND(17)
550     FOR F=23 TO 23-M STEP-1
560       PRINT £102,AT F,V:H$
570       LET W(F,V)=1
580     NEXT
590   NEXT
600 END DEF
610 LET R=MAX(P,R) ! rekord meghatarozasa
620 FOR Y=F TO 22
630   PRINT £102,AT Y,V:" "
640   PRINT £102,AT Y+1,V:"*--*"
650 NEXT
660 PRINT £102,AT 2,2:"tovabb, vege (t/v)"
670 LET Q$=INKEY$ ! ujabb jatek inditasa
680 IF Q$="t" THEN 190
690 IF Q$="v" THEN 710
700 IF Q$<>"v" OR Q$<>"t" THEN 670
710 PRINT £102,AT 1,20:"rekord=";R

A játékot a szóköz billentyűvel vezérelhetjük. A képernyő tartalma a W (25,38) nevű, ill. méretű tömbben is megtalálható. Ahol célpont van, azt a helyet a tömbben 1, míg az üres képernyőterületet 0 jelzi. Erre azért van szükség, mert a játékot pontszámra kívánjuk játszani. A folyamatosan előre és egyre lejjebb szálló repülőgépről (R$) a szóköz billentyű segítségével indíthatjuk el a bombát (B$). A bomba útját a képernyőre rajzolja a program, de a W tömbben vizsgálja, hogy ér-e pontot a lövés. Ha a W tömb sor, oszlop elemének értéke 1, akkor a pontszámot növeli, egyben a mátrix aktuális elemét 0-ra állítja. A játék mindaddig folytatható, amíg a repülőgépünk neki nem ütközik a képernyőn lévő rajzjelnek, azaz a R$ V,F koordinátájának megfelelő mátrix elem érték nulla.
Új játékot a "t" billentyű lenyomásával indíthatunk. A Basic-ben írt játék sebessége természetesen vitatható. A továbbra is Basic programhoz ragaszkodók, p1. a GET-nél és a PRINT-nél találnak más, futást gyorsító megoldást, amit ebben a programban is felhasználhatnak.
Az 50. program szintén a képernyő tartalmát tárolja, itt most az L (19,36) tömbben.

1 PROGRAM "Ariadne.bas"
100 ! Ariadne
101 RANDOMIZE
105 TEXT 40
110 DIM L(19,36),H(500)
120 NUMERIC X,Y
130 LET U,S,H(0)=0
140 PRINT AT 1,1:"Turelem!"
150 CALL LETREHOZ
160 CALL RAJZOL
170 IF Y=3 THEN 350 ! megtalaltuk a kijaratot
180 IF L(Y,X+1)<>-1 THEN 240
190 IF L(Y,X+1)=-1 AND L(Y-1,X)=-1 THEN 320
200 LET YE=Y:LET XE=X:LET Y=Y-1:CALL TANUL
210 GOTO 170 ! ha meg lehet, menj felfele
220 IF L(Y+1,X)<>-1 THEN 290
230 IF L(Y,X+1)=-1 THEN 170
240 LET YE=Y:LET XE=X:LET X=X+1:CALL TANUL
250 GOTO 220 ! ha meg lehet menj jobbra
260 IF Y=19 THEN 480 ! visszajutott a bejaratjoz
270 IF L(Y,X-1)<>-1 THEN 330
280 IF L(Y+1,X)=-1 THEN 220
290 LET YE=Y:LET XE=X:LET Y=Y+1:CALL TANUL
300 GOTO 260 ! probald megegyszer lefele
310 IF L(Y-1,X)<>-1 THEN 200
320 IF L(Y,X-1)=-1 THEN 260
330 LET YE=Y:LET XE=X:LET X=X-1:CALL TANUL
340 GOTO 310 ! probaljuk balra
350 LET X=35:LET Y=19:LET R$="*":CALL UTVONAL
360 PRINT AT 22,5:" u = barmi, m = megegyszer ez"
370 LET A$=INKEY$
380 IF A$="m" THEN 410
390 IF A$="" THEN 370
400 GOTO 130
410 LET R$=" ":CALL UTVONAL
420 LET R$="*":CALL UTVONAL
430 GOTO 360
440 DEF HELY
450   IF INKEY$="u" THEN RUN ! ujat kezdunk
460   LET U=U+1:LET H(U)=100*X+Y
470 END DEF
480 PRINT AT 22,4:"Sajnos nem lehet atjutni"
490 IF INKEY$="" THEN 490
500 RUN
510 DEF TANUL
520   PRINT AT YE,XE:" "
530   PRINT AT Y,X:CHR$(154):CALL HELY
540   IF L(Y,X)<>0 THEN LET U=L(Y,X)
550   IF L(Y,X)=0 THEN LET L(Y,X)=U
560 END DEF
570 DEF UTVONAL
580 LET W=0
590 FOR I=1 TO U
600   LET X=INT(H(I)/100):LET Y=MOD(H(I),100)
610   PRINT AT Y,X:R$
620 NEXT
630 END DEF
640 DEF LETREHOZ
650   FOR F=3 TO 19
660     LET T=(F/2<>INT(F/2))
670     FOR V=4 TO 36
680       LET L(F,V)=T
690     NEXT
700     LET L(F,4),L(F,36)=-1
710     IF F=3 OR F=19 THEN 760
720     LET A=2-T*4+RND(3)
730     FOR I=1 TO A
740       LET L(F,7+RND(28))=NOT(T)
750     NEXT
760   NEXT
770   LET X=35:LET Y=19:LET L(3,5),L(Y,X)=0
780 END DEF
790 DEF RAJZOL
800   CLEAR TEXT
810   FOR F=3 TO 19
820     FOR V=4 TO 36
830       IF L(F,V)=-1 THEN PRINT AT F,V:CHR$(159)
840     NEXT
850   NEXT
860 END DEF

Ebben a programban a kép előbb készül el a tömbben és a mátrix elemeinek értéke alapján rajzolja a képernyőre a labirintus képét a program a 760-830 sorok segítségével. Ha a labirintus így felülről nézve nem járható át, akkor célszerű az "u" betű lenyomásával új labirintust rajzoltatni. A R$ egy emberke, vagy egy csillag karakter a képernyő jobb alsó sarkán lévő bejáraton "bemegy" a labirintusba és a jobb fal súrolásának elvét következetesen betartva, megkeresi a kijáratot (ha van ilyen). A fal vagy átjáró felismerése itt is a tömb elemeinek figyelésével történik.
A H egydimenziós tömbben (vektor) az áthaladás során azoknak a pontoknak a koordinátáiból képzett értéket tárolja a program, amelyek az áthaladáshoz szükségesek. A kerülőket, a kétszer, vagy többször bejárt pontokat nem veszi fel ebbe a vektorba. Így, mire a bábu keresztülvergődik a labirintuson, addigra "meg is tanulja" a program a helyes útvonalat. Az "m" betű lenyomására újra meg újra keresgélés nélkül felrajzolja a kitapasztalt célszerű útvonalat. Ehhez a koordinátákat a H tömb értékeiből számítja ki. Új labirintus, mint mindig, a megtalált útvonal után is "u" betűvel kérhető a programtól.
A királynők a sakktáblán című 51. program meghatározza azt (azokat) a bábu elhelyezési lehetőségeket egy n x n méretű sakktáblán, mely mellett az n db királynő egymást nem képes leütni.

1 PROGRAM "Kiralyno.bas"
100 ! kiralynok a sakktablan
110 TEXT 40
120 INPUT PROMPT "Vezerek szama: ":V
130 IF V<3 OR V>7 THEN 120
140 CLEAR TEXT
150 PRINT "Vezerek szama: ";V
160 CALL TABLA
170 PRINT AT 15,8:"abcdefgh"
180 SET CHARACTER 154,0,60,60,24,126,24,60,102,0 ! kiralyno fekete alapra
190 SET CHARACTER 155,255,195,195,231,129,231,195,153,255 ! kiralyno feher alapra
200 DIM T(V),S(8,8)
210 FOR X=1 TO 8
220   FOR Y=1 TO 8
230     LET S(X,Y)=((X+Y)/2=INT((X+Y)/2)) ! sakktabla feher fekete jelzes bejegyzese
240   NEXT
250 NEXT
260 LET I=0:LET C=3
270 LET I=I+1:LET T(I)=1
280 IF I=1 THEN 320
290 FOR K=1 TO I-1 !utes vizsgalat
300   IF T(I)=T(K) OR ABS(T(I)-T(K))=I-K THEN 460
310 NEXT
320 IF I<V THEN 270
330 CALL TABLA
340 FOR L=8 TO 7+V
350   PRINT AT 14-T(L-7),L:CHR$(154-S(8-T(L-7),L-7)) ! a sakktabla szinetol fuggo vezer kirajzolasa
360 NEXT
370 PRINT AT 1,20:"a b c d e f g h"
380 PRINT AT C,19:"";
390 FOR A=1 TO V ! eredmenytabla kiiras
400   PRINT T(A);CHR$(184);
410 NEXT
420 IF C>=22 THEN LET C=3
430 LET C=C+1
440 IF C>=22 THEN LET C=3
450 LET I=I-1
460 LET T(I)=T(I)+1
470 IF T(I)<=V THEN 280
480 LET I=I-1
490 IF I>0 THEN 460
500 IF C=3 THEN PRINT AT 20,3:"nincs megoldas"
510 IF C<>3 THEN PRINT AT 20,3:"Kesz"
520 END
530 DEF TABLA
540   FOR J=1 TO 8
550     PRINT AT 5+J,5:9-J;
560     LET A$=" "&CHR$(159)
570     IF J/2=INT(J/2) THEN LET A$=CHR$(159)&" "
580     FOR A=1 TO 4
590       PRINT A$;
600     NEXT
610   NEXT
620 END DEF

A sakktáblán biztosítani kell a sötét és világos mezón lévő eltérő színel bábu rajzolási lehetőségét. Ez az üthetőség szempontjából ugyan közömbös, de a láthatóság megköveteli. E célra az átdefiniált CHR$ (154), CHR$ (155)-öt használja a program.
Az egy-egy vezér által pásztázott mezőket az S tömbben jelzi a program. A vezéreket sorba elhelyezi a nem veszélyeztetett mezők valamelyikére és az újonnan táblára helyezett (képzelt) vezér által veszélyeztetett mezőket jelöli. A vizsgálatot elvégzi, majd a táblán rajzban is megjeleníti és táblázatos formában ki is írja a megoldásokat.

A képernyőn ablakot nyit meg, amelyen egyszerre több is lehet. Az ablak tartalma a háttérben is előkészíthető és a kívánt esetben a kész képernyőrészlet (szöveg vagy ábra) előhívható, megjeleníthető. Ezzel a lehetőséggel élve szinte mozgófilmszerű hatás érhető el Basic utasítások segítségével. Fényújságot mutat be az 52. program.

1 PROGRAM "Fenyujs.bas"
100 ! Fenyujsag
110 SET VIDEO Y 2
120 SET VIDEO COLOUR 3
130 SET VIDEO MODE 1
140 OPEN £2:"video:"
150 OPEN £3:"video:"
160 CLEAR SCREEN
170 !INPUT K$
180 LET K$="Kellemes karacsonyi unnepeket kivanok minden kedves ENTERPRISE tulajdonsnak"
190 LET K$=" "&K$
200 LET H=LEN(K$):LET S=0
205 LET S=S+1:LET A$=K$(S:S+8)
210 FOR I=88 TO 16 STEP-32
220   SET £2:INK 255
230   PRINT £2:CHR$(26)
240   PLOT £2:I,70,:PRINT £2:A$
250   DISPLAY £2:FROM 1 TO 2 AT 10
260   SET £3:INK 255
270   PRINT £3:CHR$(26)
280   PLOT £3:I-16,70,:PRINT £3:A$
290   DISPLAY £3:FROM 1 TO 2 AT 10
300 NEXT
310 GOTO 205

A szöveg max. 247 karakter hosszú lehet, ebből a képernyőn egyidejűleg nyolc - a VIDEO MODE és COLOUR által meghatározott méretű - nagybetű látható. A szöveg mindig egy karakterrel lép balra, hogy ez a léptetés ne okozza a kép szétszakadását, a szöveg elmosódását, ezért felváltva íratjuk ki az egyik és a másik video lapra az egy-egy karakterrel odébb léptetett szöveget. Amikor a léptetés elkészült, akkor jelenítjük meg a kész képernyőtartalmat. Ehhez hasonló megoldásokat találhatunk még a TIME$ függvény kapcsán is, az idő kijelzésére.
A DISPLAY utasítás segítségével animáció valósítható meg az Enterprise 128-ason. Az Enterprise 128-as a hazánkban elterjedt személyi számítógépek között egyedülálló mértékben segíti az animációt. Sőt a hardver által lehetővé tett szolgáltatások nagy része Basic-ből is elérhető. Ezen a géptípuson tisztán Basic nyelven, viszonylag kis munkaráfordítással írható olyan (vagy jobb) program, mint amilyen más típuson csak speciális alkalmazói szoftver (pl. C64, GIGA MOVIE), vagy gépi kódú rutinok felhasználásával készíthető.
A folyamatos, vibrálás mentes mozgásérzet elérésének kulcsa:

• A látható képernyőn ne történjen nagyobb változás. Az egyes fázisok közötti átalakulás a háttérben, láthatatlanul menjen végbe!
• Az egyes fázisrajzok kellő gyakorisággal váltsák egymást! Elvileg másodpercenként legalább 16 képváltás szükséges a folytonosság-érzethez.

Az Enterprise IS-BASIC-ben mindkét feltétel teljesíthető. A munka során nagyszámú grafikus csatorna (egy-egy rajzlap) nyitható. Ezek bármelyikére rajzolhatunk akár láthatóan, akár "vakon" - a háttérben - és bármikor megjeleníthetőek a képernyőn. Ezzel teljesül az első feltétel: egy-egy elkészített fázisrajz készen áll a memóriában a megjelenítésre várva. A második feltétel is a hallatlanul sokoldalú video egység (NICK-chip) és a kiszolgáló szoftver révén teljesíthető. A két fázisrajz közötti átkapcsolás gyakorlatilag pillanatszerű: az egyik tv-képet még az első rajz alapján generálja a chip, az 1/25-öd másodperc múlva következő képen már a másik rajzot látjuk.
Természetesen nem kis probléma a fázisrajzok időre való elkészítése. Az elvileg ideális megoldás - amelyben az új rajzot a megjelenések közötti időben a program készíti el - a Basic sebessége mellett nemigen érhető el. Csak egészen egyszerű változások esetén kapunk viszonylag folytonos mozgásképet. Ebben a technikában lényegében két lapon dolgozunk.
A mozgássor felépítésének algoritmusa a következő lehet:

• az n. fázisrajz elkészítése az 1. lapon
• az 1. lap megjelenítése
• a 2. lap előkészítése [az (n-1). fázisrajz törlése]
• az (n+1). rajz elkészítése a 2. lapon
• a 2. lap megjelenítése
• az 1. lap előkészítése (az n. rajz törlése)
• az (n+2). rajz elkészítése az 1. lapon; vissza a ciklus elejére

Lényegesen egyszerűbb a helyzet, ha egy ciklikusan ismétlődő rajzsorozatot szeretnénk megjeleníteni (ilyen az 53. mintaprogram), vagy ha tetszőleges sorrendben, de adott rajzkészletből dolgozunk.

1 PROGRAM "Mozgo.bas"
100 ! Mozgoabra
110 SET VIDEO MODE 1
120 SET VIDEO COLOR 1
130 SET VIDEO X 15
140 SET VIDEO Y 15
150 FOR N=1 TO 12
160 OPEN £N:"video:"
170 CALL FAZIS(N)
180 NEXT
190 FOR N=1 TO 12
200   DISPLAY £N:AT 1 FROM 1 TO 15
210   FOR T=1 TO 20
220   NEXT
230 NEXT
240 FOR N=12 TO 1 STEP-1
250   DISPLAY £N:AT 1 FROM 1 TO 15
260   FOR T=1 TO 20
270   NEXT
280 NEXT
290 GOTO 190
300 DEF FAZIS(N)
310   DISPLAY £N:AT 1 FROM 1 TO 15
320   SET £N:INK 255
330   PLOT £N:260+N*5,270+6*(18-N) ELLIPSE 20,20
340   PLOT £N:220-N*5,270+6*(18-N) ELLIPSE 20,20
350   PLOT £N:240,256-6*(18-N);ELLIPSE N*10,20
360   PLOT £N:240,260;ELLIPSE 20,5*(15-N)
370   PLOT £N:240,270,ELLIPSE 12*N+80,270-16*N
380   PLOT £N:240,260+6*(15-N),PAINT
390 END DEF

Ekkor ui. a fázisrajzok (bemutatás előtt) tetszőleges idő alatt készíthetőek el az egyes video lapokon. A megjelenítéskor ismét élvezhetjük az Enterprise előnyeit. A többi géptípuson általában egy (vagy igen kevés) memóriaterület jeleníthető meg. A kijelzésre szánt képet - ideiglenes helyér6l - egy blokkmozgató rutinnal kell erre a területre vinni, aminek végrehajtási ideje általában nem elhanyagolható. Az Enterprise gépen a felső négy szegmensben bármilyen memóriaterület megjeleníthető. Ezért ezen a gépen nem kell adatokat mozgatni. Elég a NICK-chippel "közölni", hogy honnan vegye a képinformációt, ami - még a Basic interpreter közvetítésével is - elég gyors az animációhoz.
Az egyetlen szűk keresztmetszetet a lapok száma jelenti, ami persze függ a lapok választott méretétől is. Pl. a mintaprogramban választott 10 x 10-es lapok esetében az operációs rendszer 29 lapnak tud helyet foglalni a memóriában. Hatékonyabb memóriagazdálkodást az operációs rendszer ismeretében, gépi kódú programmal érhetünk el.
Az 54. mintaprogram - az animációs lehetőségek egyszerű illusztrációjaként - két egymást metsző színes kört mozgat egy 10 x 10 karakternyi méretű grafikus ablakban.

1 PROGRAM "Golyok.bas"
100 ! Golzok
110 SET VIDEO MODE 1
120 SET VIDEO COLOR 1
130 SET VIDEO X 10
140 SET VIDEO Y 10
150 FOR N=1 TO 20 ! lapok nyitasa
160   OPEN £N:"video:"
170   CALL RAJZOK(N)
180 NEXT
190 LET A$=INKEY$
200 IF A$="" THEN 190 ! animacio billentyunyomasra indul
210 FOR N=1 TO 20 !megjelenites
220   DISPLAY £N:AT 1 FROM 1 TO 10
230   CALL KESLELTET
240 NEXT
250 FOR N=20 TO 1 STEP-1
260   DISPLAY £N:AT 1 FROM 1 TO 10
270   CALL KESLELTET
280 NEXT
290 GOTO 210
300 DEF KESLELTET
310   FOR I=1 TO 10
320   NEXT
330 END DEF
340 ! Fazisrajzok
350 DEF RAJZOK(N)
360   DISPLAY £N:AT 1 FROM 1 TO 10
370   SET £N:PALETTE BLACK,GREEN,YELLOW,RED
380   PLOT £N:0,0;319,0;319,359;0,359;0,0,
390   SET £N:INK 1
400   PLOT £N:-10+16*N,160,ELLIPSE 70,70,
410   SET £N:INK 2
420   PLOT £N:PAINT
430   SET £N:INK 3
440   PLOT £N:328-16*N,200,ELLIPSE 70,70,
450   PLOT £N:328-16*N,245,PAINT
460   SET £N:INK 1
470   PLOT £N:-10+16*N,130,
480   PLOT £N:PAINT
490 END DEF

Más rajzsorozatnál a 150-180. sorok helyett építhető be a saját rutin, vagy az azt hívó utasítás. Természetesen az előre-hátra pörgetés is fölösleges lehet. A DISPLAY utasításokat AT utáni paraméterével adhatjuk meg, hogy a 10 sornyi grafikus ablak a képernyő hányadik sorától jelenjen meg. Ha az animált ablakot egy előre megrajzolt grafikus képernyő közepére "vetítjük", ügyes rajztechnikával elérhető, hogy a mozgó képrészletet alul-felül egy álló háttér egészíti ki.

A program egy részének ismétlése legegyszerűbben (és a legkevesebb veremterület felhasználásával), ezzel az utasításpárral valósítható meg.
A DO/LOOP utasításpór önmagában végtelen ciklust eredményez. A ciklus befejezését feltétel teljesüléséhez (vagy nem teljesüléséhez) kell kötni. A ciklus szervezhető elöl és hátul teszteléssel, így bizonyos feltételek teljesülését6l, és a feltétel vizsgálatának helyétől függően más-más futási eredményt kaphatunk. A DO/LOOP struktúrának előnye a FOR/NEXT szerkezettel szemben az is, hogy a ciklus magjaként lefutó programrész más-más lépésközt alkalmazhat. Erre mutat példát az 55. program, melynek 300-370. sorai egy függvény gyökének meghatározására szolgálnak.

100 ! gyokkereses
110 INPUT PROMPT "y=":F$
120 TEXT
130 PRINT "220 def y(x)=";F$
140 PRINT "230 f$=";"""";F$;""""
150 PRINT "run 200"
160 SET FKEY 2 CHR$(177)&CHR$(13)&CHR$(13)&CHR$(13)
170 ! angol POKE 48816,66:POKE 48818,4
180 POKE 43915,29:POKE 43917,4 ! nemet
190 END
200 TEXT
210 CLEAR FKEYS
220 !!!!!!!!!!!!!!!!!
230 !!!!!!!!!!!!!!!!!
240 PRINT "y=";F$:PRINT
250 INPUT PROMPT "xmin=":XA
260 INPUT PROMPT "xmax=":XF
270 LET S1=SGN(Y(XA))
280 IF S1=SGN(Y(XF)) THEN PRINT "nem garantalt a gyok"
290 INPUT PROMPT "pontossag=":EP
300 DO
310   LET V=(XA+XF)/2
320   IF S1=SGN(Y(V)) THEN
330     LET XA=V
340   ELSE
350     LET XF=V
360   END IF
370 LOOP UNTIL ABS(XA-XF)<2*EP
380 PRINT "Egy gyok:";(XA+XF)/2

A program további ötletet-trükköt is tartalmaz. A függvény inputként kozolhet6 a számítógéppel, és azt kvázi direkt módban a program - önmagának felülírásával - felveszi a 200-230. sorokba. A program újraindítását a billentyűpuffer és a funkcióbillentyű átdefiniálásának lehetősége biztosítja. A billentyűpuffer a különböző gépeknél más-más helyen helyezkedik el, ezért vagy a 170., vagy a 180. sor építendő be a programba. A függvény vizsgált tartományának birtokában a DO/LOOP struktúra számköz-felező eljárással megkeresi a függvény EP pontosságú gyökét. Minthogy a gyökkereső algoritmus a függvényérték előjelváltozását figyeli, csak olyan esetben várható az adott intervallumban lévő gyök megtalálása, ha a függvény átmetszi a y=0 egyenest.
A gyök behatárolásának gyorsaságát és pontosságát a függvényérték kiszámítása során felhasznált változó V érték biztosítja (310. sor).
A ciklus szervezésének több lehetséges módját biztosítja az IS-BASIC. Hogy melyik megoldást választja a felhasználó, azt a programozó előtanulmányai, programozói stílusa jelöli ki. A strukturált, áttekinthető programírást a DO/LOOP struktúra talán jobban szolgálja, mint a FOR/NEXT szerkezet.

A számítógép Neumann János által megfogalmazott ismérvei alapján kell, hogy ciklus szervezésére alkalmas legyen. A program egyes részeinek ismétlését különböző utasításokkal, szerkezettel lehet megvalósítani.
Az Enterprise FOR-NEXT struktúrája a kezdeti és végértékeket a ciklus elején vizsgálja, így ennél a számítógépnél - más típusú Basic nyelvjárástól eltérően - van nullaszor lefutó ciklus is, ha a végérték kisebb mint a kezd6érték, akkor a ciklust mintegy átlépi, de ilyenkor is mint minden más esetében a ciklus után a ciklusváltozó a végérték plusz egy értékét veszi fel. Az IS-BASIC érdekessége (de különösebb jelentősége nincs), hogy a NEXT utáni változónevet nem veszi figyelembe. Így a ciklusok egymásba ágyazásának rendjét az interpreter "kézben" tudja tartani. Nem fordulhat elő (mint más gépek esetében), hogy egy korábban megkezdett ciklust idő előtt zárjunk le (56. program).

10 ! NEXT furcsasagok
20 FOR A=1 TO 4
30   FOR B=1 TO 4
40     PRINT "a=";A,"b=";B
50   NEXT ABRAKADABRA
60 NEXT AKARMI

A ciklusok végrehajtásához a Basic veremben az interpreter 24 byte hosszú ,,csomagot" tárol. Ez a csomag Basic-ből hozzáférhető, mert a ciklus feldolgozása közben a veremnek ez az utolsó bejegyzett eleme. Erre az utolsó elemre a 228H-229H rendszerváltozó mutat. Márpedig, ha írásra és olvasásra is elérhető, akkor mi magunk is benyúlhatunk ebbe a területbe. De minek? Például arra, hogy menetközben, a ciklus futása közben a ciklus bizonyos jellemzőit megváltoztassuk. Ezek közül a jellemző értékek közül a végérték és a lépésköz jöhet számításba.
A végérték módosítása a kezdőérték felé nem lehet indokolt, mert ha az eredeti végérték elérése el6tt kívánjuk befejezni a ciklust, akkor használhatjuk az egy bizonyos feltételhez kötött EXIT FOR utasítást. A lépésköz megváltoztatása (súrolja a programozói jólneveltség határait, de) igen érdekes futásokat eredményezhet. Nézzük pl. a Fibonacci-sor előállítását.
A Fibonacci-sor előállításának szabálya:
A sor első két eleme 1 és 1. A továbbiakat mindig az előző két elem összegeként értelmezzük

ni = ni-1+ni-2

Más értelmezésben számegyenesen egy adott értékhez képest olyan nagyot kell előre lépni, mint az előző elem értéke volt. A kiírandó számok egymásután, tehát mindig változó lépésközzel (STEP?!) következnek.
Nézzük meg az 57. programot.

100 ! Fibonacci maskent
110 LET E=1
120 FOR I=0 TO 76000 STEP 0 ! step valtozni fog !!!
130   PRINT I+E ! n(x)=n(x-2)+n(x-1) ahol n(x-1.)=I
140   ! ha a lepeskoz egesz akkor a FOR csomag 9. 10. elemet eleg modositani
150   POKE PEEK(552)+256*PEEK(553)+9,MOD(E,256)
160   POKE PEEK(552)+256*PEEK(553)+10,INT(E/256)
170   LET E=I !n(x-2)=n(x-1)
180 NEXT

A program megértéséhez tudni kell, hogy a FOR-NEXT csomag a Basic veremben az IY regiszter tartalma által meghatározott címen kezdődik. Ehhez mi nem tudunk hozzáférni, de ez az érték a 228H-229H címről PEEK-kel kiolvasható.
A csomagban a lépésköz (STEP) értéke a számábrázolásnál megismert módon található meg. A tárolt érték a bejegyzés (IY által meghatározott címtől) 9-15. byte-ja. A Fibonacci-sor lépésközei egész számok lévén nekünk itt csak az első két (BCD számábrázolás!) helyen tárolt érték változtatásával kell foglalkoznunk. A program 140-150. sorai végzik el a lépésköz a STEP értékének megváltoztatását, mindig az előző eredmény értékére. Minthogy a lépésköz értéke 255-nél is nagyobb lehet, ezért kell mind a két byte-ot helyi érték szerint helyesen megváltoztatni.

Az utasítás egy karakter beolvasását teszi lehetővé a kijelölt csatornáról. Általában a beolvasást a billentyűzetről, a magnóról, lemezmeghajtóról vagy a hálózatról végezzük.
Alig jut az eszünkbe, hogy a beolvasást a képernyőről végezzük el. Pedig GET esetében kijelölhető a képernyő is, mint ahonnan karaktert akarunk leolvasni. Jó hasznát vehetjük ennek a lehetőségnek, ha TEXT üzemmódban kívánjuk meghatározni azt, hogy a képernyő adott pozícióján van-e és ha igen, milyen karakter. Az 58. program egyszerű játék lehetőséget biztosít.

1 PROGRAM "GET.bas"
110 ! kepernyotartalmat figyel
120 CALL INIC
130 LET Y=5+RND(12):LET X=3+RND(6):LET P=0
140 PRINT AT Y,X:"*";
150 PRINT AT 5+RND(12),30+RND(6):"O";
160 LET A=JOY(0)
170 IF A=0 THEN 160
180 LET YE=Y:LET XE=X
190 LET Y=Y+(A=8)-(A=4):LET X=X+(A=2)-(A=1)
200 !
210 !********************
220 PRINT £102,AT Y,X:;
230 GET £102:P$
240 !********************
250 !
260 IF P$=CHR$(31) OR P$="O" THEN
270   PRINT AT 1,15:"""T""nyomasara var ";
280   PING :PING
290   IF INKEY$<>"t" THEN 290
300 RUN
310 END IF
320 PRINT AT YE,XE:CHR$(159)
330 PRINT AT Y,X:"*"
340 LET P=P+1:PRINT AT 1,1:"Pontszam= ";P;
350 GOTO 160
360 DEF INIC
370   RANDOMIZE
380   SET STATUS OFF
390   SET KEY CLICK OFF
400   ! SET KEY RATE 1
410   ! SET KEY DELAY 10
420   CLEAR SCREEN
430   FOR I=3 TO 22
440     PRINT AT I,2:CHR$(159);
450     PRINT AT I,38:CHR$(159);
460   NEXT
470   FOR I=2 TO 38
480     ! PRINT £102,AT 2,I:CHR$(159);
490     PRINT AT 2,I:CHR$(159):!
500     ! print £102,at 23,i:chr$(159);
510     PRINT AT 23,I:CHR$(159);
520   NEXT
530   FOR I=1 TO 200
540     LET X=3+RND(35)
550     LET Y=3+RND(20)
560     PRINT AT Y,X:CHR$(159);
570   NEXT
580   PRINT AT 1,15:"""*"" botkormannyal mozog ";
590 END DEF

A képernyőn véletlenszerben akadályok helyezkednek el. A karaktert kell ebben a labirintusban a botkormány segítségével a 0 karakterhez elvezetni. A program 220-230. sora figyeli a képernyő adott pozíci6ját. Ha a bábunkat akadálynak vezetjük vagy ha elérjük a célt, vége a ,j4téknak". Valahány lépést megteszünk mindig egy pontot kapunk. A listában ! jellel jelölt 400-410., valamint 480. és 500. sorok alkalmazása gyorsabbá teszik a program futását. Ilyenkor viszont a 490. és 510. sorokra nincs szükség.

Az alprogram hívás utasítása. A GOSUB utasítást az interpreter, a tokenizá16 rutin más utasítással közös programsorban is elfogadja, de csak a sor utolsó utasításaként használjuk. Ez azért célszerű, mert a GOSUB utasítás végrehajtása után az alprogramból nem a meghívást követ6 memóriacímre, hanem a következ6 programsorra tér vissza a program a RETURN hatására. Az alprogram önmagát is többször - akár 14720 alkalommal - is meghívatja. Ez a meghívási mélység csak a szabad memóriaterület nagyságától függ. Nyilván ilyen meghívás sorozatot nem végzünk, de egy kvázi rekurzió kedvéért többször is felhasználhatja a szubrutin saját magát. Az 59. program szerinti feltételhez kötött visszatérés esetén az interpreter a Basic vermet rendben hagyja maga után.

100 ! szubrutin onmagat hivja
110 DEF Y=PEEK(552)+256*PEEK(553)
120 PRINT Y
130 LET U=1:LET A=-1:GOSUB 160
140 PRINT Y
150 END
160 LET A=A+1
170 PRINT A;".hivas ","verem mutato:";Y
180 IF A=6 THEN RETURN
190 GOSUB 160
200 PRINT U;".rendez ","verem mutato:";Y
210 LET U=U+1
220 RETURN

Olyan esetben, ha valamely feltétel teljesülése, vagy nem teljesülése miatt az alprogramból (subrutinból) úgy kellene visszatérni, hogy ne az interpreter által kijelölt hívás utáni helyre kerüljön a vezérlés, akkor a vermet előbb rendezni kell. Ehhez tudni kell azt, hogy a GOSUB utasítás három byte hosszú csomagot tárol, amit a RETURN leemel, és ebből állapítja meg a visszatérési címet.
A RETURN n jellegű utasítás úgy valósítható meg a 60. program szerint, hogy bizonyos feltétel teljesülése esetén GOTO-val túllépünk a RETURN utasításon. Ott leemeljük a GOSUB csomagot, ez után GOTO-val, vagy ON A GOTO utasítással már tetszőleges helyen folytatható a program futása.

1 PROGRAM "Verem.bas"
100 ! verem rendezes RETURN n
110 ! felkialtojeles sorok elhagyhatokak
120 PRINT PEEK(552)+256*PEEK(553) !
130 GOSUB 200
140 PRINT PEEK(552)+256*PEEK(553) !
150 PRINT "szabalyosan vissza"
160 END
170 PRINT "mashol vagyok"
180 PRINT PEEK(552)+256*PEEK(553) !
190 END
200 PRINT PEEK(552)+256*PEEK(553) !
210 PRINT "menu":PRINT
220 PRINT "0 akkor RETURN-nel vissza"
230 FOR I=1 TO 5
240   PRINT I;I*1000;". sorra GOTO-val"
250 NEXT
260 INPUT PROMPT "ha nem 0 akkor mashova ":A
270 IF A=0 THEN RETURN
280 LET P=PEEK(552)
290 IF P<253 THEN
300   POKE 522,P+3
310 ELSE
320   POKE 522,P-253
330   POKE 553,PEEK(553)+1
340 END IF
350 PRINT "verem rendezve"
360 IF A>5 THEN 210
370 ON A GOTO 1000,2000,3000,4000,5000
380 END
1000 PRINT "most: 1000. sor":STOP
2000 PRINT "most: 2000. sor":STOP
3000 PRINT "most: 3000. sor":STOP
4000 PRINT "most: 4000. sor":STOP
5000 PRINT "most: 5000. sor":STOP

A feltételhez kötött, vagy feltétel nélküli ugró utasítást biztosítja a megadott sorszámra. Csak élő sorszám lehet, amit az utasításban megadunk.
A GOTO végrehajtó utasításnak van egy igen széles körű vizsgálati szakasza (5. szegmens D1ECH-D211H), mely az ugrás elvégzése előtt a Basic vermet rendbe teszi. Így FOR-NEXT, DO/LOOP blokkokból is ki lehet lépni GOTO-val. Ez a vizsgálat ugyanazokat a verem tisztításokat elvégzi, mint az EXIT FOR, vagy EXIT DO utasítás, ha a GOTO-val megcímzett sor a struktúrán kívül helyezkedik el. Azoknál talán még jobb is, mert nemcsak a blokkzáró utasítás utánra, hanem a blokk kezdete elé is el lehet ugorni. Az örök szabályra viszont vigyázni kell, a blokkokba "beugrani" nem lehet!

A rajzolási, a nagyfelbontású grafikus lehetőségek az Enterprise számítógépen Basic-ből könnyen elérhetők, ehhez azonban a GRAPHICS utasítással a megfelelő lapot ki kell választani. Egy grafikus képernyő 14400 byte memóriaterületet vesz igénybe. Alapértelmezésű gépben a grafikus képernyő két részben, két külön szegmensen található meg. Az első rész a 254. szegmensen 11308-16383 és a második rész a 255. szegmensen 0-9323 címen található. Természetesen elég rugalmas az Enterprise memória szervezése ahhoz, hogy ez is megváltoztatható legyen. Ha eleve belapozzuk a 177dec portra a 254. szegmenst, akkor az egész grafikus képernyőt egy helyen is megtaláljuk a 27692-42091 címen. A kétféle lehetőség kihasználására, adott esetben a program futásának idejére való hatását a 61. és a 62. program segítségével tanulmányozhatjuk.

100 ! kifeherito POKE grafikus kepernyo memoriateruletere
110 GRAPHICS
120 TIME "00:00:00"
130 FOR I=11308 TO 16383 ! a kepernyo eleje az osztott memoriaban
140   SPOKE 254,1,255
150 NEXT
160 FOR I=0 TO 9323 ! a kepernyoterulet masodik resze
170   SPOKE 255,1,255
180 NEXT
190 PRINT TIME$

100 ! kifeherito POKE athelyezett grafikus kepernyo memoriateruletere
110 GRAPHICS
120 OUT 177,254
130 TIME "00:00:00"
140 FOR I=27692 TO 41836
150   POKE 1,255
160 NEXT
170 PRINT TIME$

A grafikus üzemmód használatának több lehetősége van. Az egyidejűleg használni kívánt színkombinációktól függően kell megválasztani a grafikus módot.

• A HIRES GRAPHICS üzemmódban a képernyő egy sora 80 byte-ból áll, az ATTRIBUTE módban pedig 40-ből.
• GRAPHICS 2. üzemmód. A sor egy byte-jának bitjei határozzák meg a rajzolást. Ahol 1-es áll, ott az INK 1 rajzol, ahol 0, ott pedig az INK 0.
• GRAPHICS 4. üzemmód. Ebben a módban egy byte négy kétbites részre oszlik. Az ilyen esetben alkalmazható négy szín kódja a PALETTA szín sorszáma 0-3 között. A byte tartalmát a kódok és pozíciók kölcsönhatása határozzák meg, az alábbiak szerint:

• GRAPHICS 16. mód esetében egy byte két részre oszlik az 1:5 N:5 2 pozíció színkódjának tárolására. Az adott pozícióról tárolt információ a 16 színárnyalatot reprezentálja az alábbiak szerint

• GRAPHICS 256. üzemmód. Az adott pozícióról tárolt információ a pont színkódja, így az egész képpont a byte által meghatározott színű lesz.
• GRAPHICS ATTRIBUTE. Attribútum üzemmódban a képernyő száznyolcvan 4 byte szélességű sorból áll. Ez azt jelenti, hogy ahol eddig két pont, két byte volt, ott most egy, kétszer olyan széles pont található. Ezeket a byteokat úgy kell elképzelni, mint a GRAPHICS 2 módban.

A különböző grafikus módok hatását ki kell ismernie a felhasználónak, ehhez minden lehető és lehetetlen alkalmat fel kell használni.
A 63. program a képernyőre egyidejűleg négy ablakot nyit, melyekre különböző VIDEO COLOR MODE-okat állít be. Az ablakokban azonos szöveg és a beállítás jellemzője látható. Ez a program biztosítja, hogy egymás mellett láthassuk, ill. összehasonlíthassuk az utasítás hatását.

1 PROGRAM "Graph1.bas"
100 ! grafikus modok
110 SET VIDEO X 40 ! megnyitando lapok szelessege
120 SET VIDEO Y 6 ! megyitando lapok magassaga
130 LET X=0
140 FOR I=3 TO 0 STEP-1
150   SET VIDEO MODE 1
160   SET VIDEO COLOUR I ! vizszintes keppontszam kijeloles x=640/2^i
170   OPEN £I+10:"video:"
180   DISPLAY £I+10:AT I*6+1 FROM 1 TO 6 ! kepernyon ablakot jelol ki a megjeleniteshez
190   SET £I+10:PALETTE 50,100,150,200
200   SET £I+10:PAPER I
210   PLOT £I+10:0,215;1279,215
220   PLOT £I+10:0,0;1279,0
230   PLOT £I+10:(640-40*2^(I+1)),200,
240   PRINT £I+10:"ENTERPRISE"
250   PRINT £I+10:"colour:";I
260 NEXT

A 64. program ENTERPRISE reklámszöveget ír a képernyőre a fekete-fehér televízió előtt ülő géptulajdonosok kedvéért csak két színű üzemmódban.

1 PROGRAM "Graph2.bas"
100 ! grafikus kepernyore ir
110 SET STATUS OFF
120 GRAPHICS
130 SET PALETTE 255,0
140 SET BORDER WHITE
150 SET PAPER 1
160 SET INK 2
170 OPTION ANGLE DEGREES
180 PLOT 480,365,ELLIPSE 400,350
190 PLOT 840,365,ELLIPSE 400,350
200 FOR X=0 TO 360 STEP 10
210   IF X=70 THEN LET X=120
220   IF X=250 THEN LET X=300
230   LET V=500+400*COS(X):LET F=370+340*SIN(X)
240   PLOT V,F,
250   PRINT £101:"ENTERPRISE"
260 NEXT
270 PLOT 660,365,ELLIPSE 100,200,PAINT
280 SET LINE MODE 3
290 PLOT 615,375,:PRINT £101:"128"

A 159. soron kezdődő ciklus kört rajzol. Igaz, hogy van erre tökéletesebb, gyorsabb lehetőség, de itt mi nem is a kör kerületét akarjuk megrajzolni, hanem a kör kerületének egyes pontjaira van szükségünk, hogy ezektől a pontoktól indulva szöveget tudjunk a képernyőre írni. A futás eredménye a 12. ábrán látható.

Még mindig reklám és még mindig kör polárkoordinátákkal felírt egyenlete, de most már GRAPHICS 16 üzemmód és a kör nem is teljes kör, hanem annak csak egy része.
Ezzel a programmal állítható elő a 13. ábra.

1 PROGRAM "Graph3.bas"
100 ! grafikus kepernyore ir 2
110 GRAPHICS 16
130 PLOT 660,345,ELLIPSE 100,180,PAINT
140 SET LINE MODE 3
150 FOR X=.7*PI TO 2.3*PI STEP PI/10
160   LET V=500+285*COS(X):LET F=370+340*SIN(X)
170   LET A$="ENTER"
180   IF X>3*PI/2 THEN LET A$="PRISE"
190   PLOT 560,375,:PRINT £101:"128"
200   PLOT V,F,:PRINT £101:A$
210 NEXT

A színes lehetőségek kihasználását bemutató program minden betóz és a szinuszhullám pontjait más-más színnel rajzolja a képernyőre. A pontok színei véletlenszerűen változnak a 14. ábrán.
Ezt a képét a 66. programmal állíthatjuk elő.

1 PROGRAM "Graph4.bas"
100 ! grafikus kepernyore villogo szines szoveg
110 GRAPHICS 256
120 LET J=0
130 FOR X=0 TO 26 ! sinusgorbe
140   LET V=45*X+50:LET F=240+240*SIN(X*PI/12)
150   SET INK RND(255):PLOT V,F;
160 NEXT
170 PLOT V,F,
180 LET A$="ENTERPRISE128"
190 FOR X=0 TO 12 ! a$ hullamvonalu kiirasa
200   LET F=400+230*SIN(X*PI/6)
210   LET S=X+1
220   IF J=1 THEN LET S=RND(250)+1
230   SET INK S:PLOT 90*X,F,
240   PRINT £101:A$(X+1:X+1)
250 NEXT
260 LET J=1
270 GOTO 130

A számítógépes grafika kedvenc alakja a 15. ábrán látható.
Mandelbrot-féle almaemberke. Az előállítására szolgáló 67. program futása bizony több órát vesz igénybe. A futás idejére az iterációk száma (K) döntő hatással van, de vagy gyorsan futó, vagy szépen tagolt ábrát biztosító megoldást eredményez az értékének megváltoztatása.

1 PROGRAM "Mandel.bas"
100 ! MANDELBROT szines
110 GRAPHICS HIRES 16
120 SET PALETTE 0,4,8,16,32,64,128,255
130 LET XA=-.8:LET XF=2.2
140 LET YA=-1.2:LET YF=1.3
150 LET DX=(XF-XA)/1200:LET DY=(YF-YA)/700
160 FOR M=350 TO 0 STEP-4
170   FOR N=0 TO 1200 STEP 8
180     LET K=0:LET XZ=0:LET YZ=0
190     LET XC=XA+N*DX:LET YC=YA+M*DY
195     DO
200       LET XX=XZ*XZ:LET YY=YZ*YZ
210       LET YZ=2*XZ*YZ-YC:LET XZ=XX-YY-XC
220       LET R=XX+YY:LET K=K+1
230     LOOP WHILE R<4 AND K<70
240     SET INK INT(K/10)
250     PLOT N,M:PLOT N,704-M
260   NEXT
270 NEXT

Igen egyszerű huzalozással össze lehet kapcsolni két vagy több (akár 32 számítógépet). Maradjunk mi a házilag valószínű kiépítésnél, amikor két számítógépet kapcsolunk össze. Az összeköttetést a 16. ábra szerint készíthetjük el.

Figyelem! A könyvben eredetileg megjelent - fentebb látható - rajz hibás, mert az a SERIAL csatlakozóhoz való, nem a NET-hez! A helyes rajz:

A csatlakozó kábel házi elkészítéséhez tudni kell, hogy a csatlakozó osztástávolsága 2,54 mm, az összekötő kábel pedig árnyékolt 5 eres legyen. Hogy mire jó az ilyen összekapcsolás, azt kipróbálhatjuk játék szinten, programfejlesztés és programírás közben is. Programfejlesztés, programírás közben az egyik gépben írt program a másikba tölthető SAVE paranccsal. A hálózati gépkijelöléseket természetesen a Felhasználói kézikönyv alapján el kell végezni. Minden gépnek egyedi száma kell, hogy legyen, ez a 18-as EXOS változóban állítható be. Ez 1-32 lehet. Ezt a számot használjuk aztán a NET eszköznél eszközszámnak. A 0-ás cím az általános, mindenkinek szóló adásra van fenntartva. Nem említi a kézikönyv, hogy minden olyan parancs, utasítás, ami a magnetofonra kiadható, használható a két számítógép között is. Lehetőség van programok összefűzésére (MERGE), de listázhatjuk (LIST) az egyik számítógép programját a másik számítógép képernyőjére.

Lemezes rendszerben pl. program átküldeni a következőképpen lehet egyik gépről a másikra:

1-es gépen:
  :COPY GAME.BAS NET2:
2-es gépen:
  LOAD "NET1:"

Az is lehetséges, hogy egyszerre több gépnek menjen az adás, az előbbi példa:

1-es gépen:
  :COPY GAME.BAS NET0:
Többi gépen:
  LOAD "NET0:"

Az adatforgalomnál, adat átküldésénél óvatosan kell eljárni. A két gépet összhangba kell hozni - még Basic szinten is - mert, ha oda-vissza adatforgalom van, akkor elképzelhető, hogy utolérik egymást a programok. Ilyenkor azután egymásra várnak. A két gép közti adatforgalomra, az egyik gépből kapott információ másik gép általi felhasználására mutat példát a 68. és 69. program.

100 ! ez talalja ki
110 ! ezt a programot kell masodikkent indítani!!!!!!!!
120 SET INTERRUPT NET OFF
130 SET NET NUMBER 1
140 OPEN £1:"net:"
150 LET ALSO=O:LET FELSO=100 ! a szamtartomany 1 es 100 kozott
160 LET TIPP=INT((ALSO+FELSO)/2)
170 LET A$=CHR$(TIPP)
180 PRINT "a tippem:";TIPP
190 PRINT £1:A$; !halozatra kuld
200 FLUSH £1 ! csatornat urit
210 GET £1:VALASZ$
220 IF VALASZ$="" THEN 210 ! addig var amíg a 2.geptol valasz nem erkezik
230 LET VALASZ=ORD(VALASZ$)
240 ON VALASZ GOTO 260,270,280
250 END
260 LET ALSO=TIPP:GOTO 160
270 LET FELSO=TIPP:GOTO 160
280 PRINT "hurra eltalaltam a szam:";TIPP

68. program

100 ! ez gondol
110 ! ezt a programot kell elsokent indítani
120 SET INTERRUPT NET OFF
130 SET NET NUMBER 2
140 OPEN £1:"net:"
150 RANDOMIZE
160 LET SZAM=RND(100):LET X=1
170 PRINT "gondoltam, talald ki";SZAM
180 GET £1:TIPP$
190 IF A$="" THEN 160 !az 1.gep tippjere var
200 LET.TIPP=ORD(TIPP$)
210 PRINT X;". tipped:";TIPP,
220 LET X=X+1
230 IF TIPP=SZAM THEN LET VALASZ$=CHR$(3)
240 IF TIPP<SZAM THEN
250   LET VALASZ$=CHR$(1)
260   PRINT "ez keves"
270 END IF
280 IF TIPP>SZAM THEN
290   LET VALASZ$=CHR$(2)
300   PRINT "ez sok "
310 END IF
320 PRINT £1:VALASZ$;
330 FLUSH £1 !valaszt kikuld az elso gepnek
340 IF TIPP<>SZAM THEN GOTO 180
350 PRINT "ezaz!"

69. program

Amikor két gép dolgozik egymástól kapott információval, akkor általában két különböző programot kell a gépekbe tölteni. Az ötletként bemutatott programok külön-külön valósítják meg a Basic tanfolyamok alapprogramjaként ismert számkitalálós játékot. Ennek a programnak két verziója van. Az egyik, amikor a számítógép "gondol" egy számot és azt kel( a gép előtt ülőnek kitalálnia. A másik lehetőség, hogy felkészítjük a gépet arra, hogy az általunk gondolt számot kitalálja. A két stratégiát a két összekapcsolt számítógépbe is betölthetjük. A tippet pedig nem mi adjuk billentyűzetről, hanem majd a másik számítógép fogja a számkitaláló program adta tippeket küldeni a számot "gondoló" gépnek. Természetesen mint ahogy két ember játéka közben, itt is illik kisegítő információt adni a számkitalálással küszködő partnernek. Tehát a tippet küldő gép "joggal vár" visszajelzést a számot "gondolótól".
Kössük össze a számítógépeket, majd helyezzük feszültség alá a rendszert! Elég az egyik számítógéphez háttértárat, magnetofont kapcsolni.
Jelöljük ki a számítógépeket a hálózat első és második gépének! (SET NET NUMBER 1) (SET NET NUMBER 2) Gépeljük be, vagy töltsük be magnetofonról az első számítógépbe a 69. programot! Ezután töltsük a programot a második számítógépbe. (SAVE "NET-2:", LOAD "NET-1:") (Természetesen dolgozhatunk párhuzamosan is, ilyenkor mindenki a saját gépébe a saját programját írja be.) Ha az egy gépen történő programírást végezzük, akkor az először betöltött program áttöltése után beolvashatjuk a 68. programot az 1. számú gépbe.
A játék úgy kezdődik, hogy elindítjuk azt a gépet, amelyikben az a program van, mely a kitalálandó számot állítja e16. Ha ennek a 2. számú gépnek a képernyőjén megjelenik a felszólítás, hogy találja ki a számot, akkor elindíthatjuk az 1. számú, számkitaláló stratégiával rendelkező számítógép programját. A tippet GET utasítás olvassa be. A két program szinkronban futását az biztosítja, hogy a beolvasást mindaddig ismétli, amíg a tipp be nem érkezik. A beérkezett tippet a számot "gondoló" program kiértékeli és attól függően, hogy ennek értéke hogyan viszonylik a kitalálandó számhoz segítő, vagy nyugtázó információt küld vissza a tippet küldőnek. Az üzenetek és tippek a számítógépek képernyőin láthatók. Amennyiben az indítási sorrendet elrontjuk, akkor mindkét program beolvasási fázisban várakozik. Ebből az állapotból csak a programok leállítása és helyes sorrendű újraindításával lehet kikerülni.

Eredendően egy gépi kódú program byte sorozatát lehet vesszővel elválasztva tárolni e függvény segítségével. Az ALLOCATE utasítással lefoglalt memóriaterületre kerülnek a függvényben tárolt byte-ok.
A megfelelő címre letárolt, eredendően hexadecimális formában megadott értékeket PEEK segítségével visszaolvashatjuk az adott memóriacímről. Ezt felismerve készíthetünk a HEX$ függvény segítségével olyan programot, mely a hexadecimális számot decimálisra váltja át. A megoldás trükkje:

DEC=ORD [(HEX$ (H$)]

A felhasználható programot pedig a következő szempontok alapján készíthetjük el:

• INPUT karaktersorozattal beírhatjuk a hexadecimális számot
• biztos ami biztos, gondoskodjunk arról, hogy a karakterek nagybetűk legyenek, ámbár a HEX$ elég intelligens végrehajtó rutinnal rendelkezik ahhoz, hogy helyesen értelmezze a betűket. (A rutin az 1. szegmens C6EF címen kezdődik.)
• ellenőrizzük, hogy a karakterek valóban hexadecimális számjegyként értelmezhetők-e. (Ez a vizsgálat is megtalálható a gépi kódú végrehajtó rutinban.)
• két karakterenként leszeletelve a H$-et a helyi értéknek megfelelően figyelembe vehetjük annak decimális értékét.

A 70. program a konkrét megoldást mutatja be.

1 PROGRAM "Hex-dec.bas"
100 ! hex -> dec
110 INPUT PROMPT "HEX szam :":H$
120 LET H$=UCASE$(H$) ! nagybetusiti a H$ karaktereit
130 LET J,D=0
140 FOR V=1 TO LEN(H$) ! karakterek vizsgalata
150   LET V$=H$(V:V)
160   IF V$>"F" OR V$<"0" OR(V$>"9" AND V$<"A") THEN LET J=1
170 NEXT
180 IF J=1 THEN 110 ! ha hex szamkent nem ertelmezheto karaktert talalt
190 IF LEN(H$)/2<>INT(LEN(H$)/2) THEN LET H$="0"&H$
200 FOR I=1 TO LEN(H$) STEP 2
210   LET D=256*D+ORD(HEX$(H$(I:I+I)))
215   ! HEX$ szeletelese, es decimaliskent valo ertelmezese
220 NEXT
230 PRINT H$;"H = ";D;"D"
240 PRINT :PRINT
250 GOTO 110

Ez a függvény az argumentum által meghatározott portról beolvas egy értéket. A 181dec port a billentyűzetet olvassa be. Korrekt beolvasást gépi kódú rutinnal végezhetünk, de Basic-ből is lekérdezhetjük a billentyűzetet. A billentyűzet beolvasható az INKEY$ függvénnyel, ezt a függvényt felhasználhatjuk, pl. billentyűgyakorlást elősegítő program írására (71. program).

1 PROGRAM "Betu.bas"
100 ! Betu gyakorlo
110 RANDOMIZE
120 SET VIDEO Y 2
130 SET VIDEO COLOUR 3
140 SET VIDEO MODE 1
150 OPEN £10:"video:"
160 CLEAR SCREEN
170 LET R=10000:LET X=1:LET A=0
180 SET £10:INK 255
190 PRINT £10:CHR$(26) ! kepernyotorles
200 LET A$=CHR$(33+RND(90)) ! veletlenkarakter eloallitasa
210 PRINT AT 8,20:A$
220 PLOT £10:570,71,:PRINT £10:A$
230 DISPLAY £10:FROM 1 TO 2 AT 10
240 LET S=0
250 LET V$=INKEY$:LET S=S+1:LET B=S*.14
260 PRINT AT 2,21:" Ez ";B;" "
270 IF V$<>A$ THEN 250
280 IF B<R THEN LET R=B
290 PRINT AT 2,1,USING "Rekord£££.£":R
300 LET A=A+B
310 PRINT AT 3,1,USING "Atlag£££.£":A/X
320 LET X=X+1
330 GOTO 180

Játékprogramokban is jól felhasználható egy billentyű lenyomásának figyelésére az INKEY$. Ezzel a függvénnyel viszont csak egy billentyű lenyomását lehet érzékelni. Adódhat olyan eset, amikor több billentyű együttes lenyomását kell kiértékelni. Ezt az együtt, több billentyűt figyelő funkciót az IN függvény segítségével valósíthatjuk meg. A billentyűállapot lekérdezéséhez ismerni kell a billentyűmátrixot. Ezt a 17. ábra mutatja be.

A 181dec (135H) port 0-3. bitje a billentyűmátrix sorkiválasztását teszi lehetővé. A sorkiválasztás után IN-nel beolvasott érték az adott sor 0-7. bitjének alakulásától függő értéket ad eredményül. A billentyű lenyomásával érintett bit értéke nullába billen. Így az egy sorban lévő karakterek együttes lenyomásával a megfelelő adatbitek értéke az egész sorról beolvasható értéket együttesen módosítják. A billentyűmátrix kiismerésére szolgáló 72. programot célszerű többször lefuttatni, mert az angol, ill. német verziójú gépeken jelentős eltérés van.

100 ! billentyumatrix kiismerese
110 INPUT PROMPT "sor kijeloles: ":Y
120 IF Y<O OR Y>9 OR Y<>INT(Y) THEN GOTO 110
130 OUT 181,Y ! sorkijeloles 181.porton
140 LET A=IN(181) ! beolvasas
150 IF A=255 THEN GOTO 130 ! ha nincs billentyu lenyomva
160 PRINT A
170 GOTO 130

Esendő adatbevitelt biztosító utasítás. Általában billentydzetr6l, de magnetofonról, hálózatról is használhatjuk. Ellentétben a GET tel meg ne kíséreljük a képernyőt kijelölni Input csatornaként, mert ilyenkor csak a RESET segít. Az utasításban jelölt változótípus vár. Ha numerikus változónevet adtunk meg és betűt akarunk beírni, akkor a program hibajelzéssel leáll. Ellentétben pl. a Microsoft Basic-kel, nem ad lehetőséget új adatbevitelre. Amennyiben karaktersorozatot kell kapnia és az vesszőt tartalmaz, akkor alapértelmezésben a vessző és az utána következő karakterek elvesznek. Ha mégis szükség van a vesszőre vagy a karaktersor elején lévő szóközökre, akkor az adatokat macskakörmök között, vagy a LINE INPUT utasítás alkalmazásával kell beírni. Ez utóbbi esetben minden karaktert, még szöveg eleji macskakörmöt is tartalmazhat a beírt szöveg.
Amennyiben ez a lehetőség is kevés és a program futását minden szempontból a felhasználótól függetlenül, biztosnak akarjuk tudni, akkor ellenőrzött INPUT rutint kell írni, hiszen nem biztos, hogy egy hiba elfogó rutinnal a később fellépő hibát korrigálni tudjuk. Ilyen adatbeírás közbeni ellenőrzési szempontok lehetnek, hogy csak számokat vagy csak bizonyos karaktereket tartalmazó, vagy csak adott hosszúságú karaktersorozatot fogadjon el a program. Az ellenőrzéseket bizonyos esetekben az INPUT utasítást tartalmazó sor után is elvégezhetjük.
Itt most nézzünk egy csokorra való ellenőrzött adatbeolvasást biztosító programot! A programok közös jellemzője, hogy a további feldolgozásra átadott adatot karakterenként olvassuk be (GET, INKEY$). Természetesen az ilyen módosított beolvasó rutinnak is (majdnem) úgy kell viselkednie mint az eredetinek. Tehát az adatok karaktereit látni kell, azokat törölni is tudni kell. Az adatbevitel végét az ENTER jelzi, az sem lenne baj, ha valami kurzor, kurzorféle is látható lenne az adatbevitel sorában.
Csak az ábécé kisbetűit fogadja el a 73. program ellenőrzött INPUT rutinja.

1 PROGRAM "Input1.bas"
100 ! ellenorzott INPUT
110 LET HOSSZ=15:LET E$="a":LET U$="z" ! beolvasasi korlatok
120 LET X=10:LET Y=10 ! kiiras helye
130 STRING Q$
140 CLEAR SCREEN
150 CALL ELL_INPUT(15,"a","z",X,Y)
160 PRINT Q$
170 END
180 DEF ELL_INPUT(HOSSY,E$,U$,X,Y)
190   PRINT "A rutin elfogad"
200   PRINT "max: ";HOSSZ;"karaktert"
210   PRINT E$;"-" U$;" tartomanyban"
220   LET Q$=""
230   DO
240     PRINT AT X,Y:Q$;"? "
250     LET A$=INKEY$:LET J=0 ! karakterenkent beolvas
260     IF A$=CHR$(13) THEN EXIT DO ! ENTER eseten beolvasas vege
270       IF LEN(Q$)>0 AND A$=CHR$(164) THEN !visszatorolhetoseg ellenorzese
280       LET Q$=Q$(1:LEN(Q$)-1):LET J=1
290     END IF
300     IF J=1 THEN 240
310     IF LEN(Q$)>=HOSSZ OR A$<E$ OR A$>U$ THEN 240
320     ! karakter elfogadhatosag vizsgalat
330     LET Q$=Q$&A$ ! karakter hozzafuzese
340   LOOP
350   PRINT AT Y,X:Q$;" "
360 END DEF

A 74. program csak számjegyeket, ill. a számsor elején (és csak ott) fogad el mínusz előjelet.

1 PROGRAM "Input2.bas"
100 ! ellenorzott INPUT
110 LET X=10:LET Y=10 ! kiiras helye
120 STRING S$
130 CLEAR SCREEN
140 CALL ELL_INPUT
150 PRINT S$
160 END
170 DEF ELL_INPUT
180   LET S$="":LET TP=0:LET EJ=0
190   PRINT "A rutin csak szamot fogad el"
200   DO
210     PRINT AT Y,X:S$;"? "
220     LET A$=INKEY$:LET J=0 ! karakterenkent beolvas
230     LET H=LEN(S$)
240     IF A$=CHR$(13) THEN EXIT DO ! ENTER eseten beolvasas vege
250     IF H>0 AND A$=CHR$(164) THEN ! visszatorolhetoseg ellenorzese
260       IF S$(H:H)="." THEN LET TP=0
270       IF S$(H:H)="-" THEN LET EJ=0
280       LET S$=S$(1:H-1):LET J=1
290     END IF
300     IF J=1 THEN 210
310     IF A$="." AND TP=1 THEN 210
320     IF A$="-" AND TP=1 THEN 210
330     IF A$="-" AND S$<>"" THEN 210
340     IF A$="." THEN LET TP=1 !tizedespont jelzo
350     IF A$="-" THEN LET EJ=1 ! elojel jelzo
360     IF A$="." OR A$="-" THEN 380
370     IF A$<"0" OR A$>"9" THEN 210
380     LET S$=S$&A$ ! karakter hozzafuzese
390   LOOP
400   PRINT AT Y,X:S$;" "
410 END DEF

A beírás során csak egy tizedes pontot írhatunk be az input adatba. Itt tehát a programnak figyelnie kell, hogy hol érkezett és érkezett-e már egy adott karakter. Természetesen azt is észre kell vennie a programnak, ha javítási szándékkal időközben kitöröltük pl. a tizedes pontot.
A csak számjegyeket és pontosan 11 karakterből álló adat elfogadását a MOD-nál is bemutatott személyi szám ellenőrző program, egy más megvalósításán keresztül figyelhetjük meg a 75. program BEVITEL blokkjában.

1 PROGRAM "Szem_szam.bas"
100 ! szemelyi szam ellenorzott INPUT-tal
110 DIM H$(12),N(12)
120 CLEAR TEXT
130 PRINT AT 8,15:"12345678901"
140 LET H=0:LET SUMMA=0:LET S$=""
145 SET £102:INK 3
150 CALL BEVITEL
155 SET £102:INK 1
160 FOR I=1 TO 12
170   READ H$(I),N(I)
180   IF I<11 THEN LET SUMMA=SUMMA+VAL(S$(I:I))*I
190 NEXT
200 LET V=VAL(S$(1:1))
210 IF V<1 OR V>8 THEN PRINT "elso karakter hibas! ":GOTO 470
220 LET A$="nem magyar ":LET B$="ferfi":LET E$="19"
230 IF V<5 THEN LET A$="magyar "
240 IF V/2=INT(V/2) THEN LET B$="no "
250 PRINT "az illeto: " A$ "allampolgarsgu " B$
260 IF (V-1) BAND 2 THEN LET E$="18"
270 PRINT "szuletesi ido: " E$ S$(2:3);" ";
280 LET V=VAL(S$(2:3))
290 IF V/4=INT(V/4) THEN LET N(2)=29
300 LET V=VAL(S$(4:5))
310 IF V<1 OR V>12 THEN
320   PRINT "hibas honap adat":GOTO 470
330 ELSE
340   PRINT H$(V);" ";
350 END IF
360 IF N(V)>=VAL(S$(6:7)) THEN 380
370 PRINT "hibas honap, nap egyeztetes":GOTO 470
380 PRINT S$(6:7)
390 PRINT "napi sorszam: " S$(8:10)
400 PRINT "ellenorzo osszeg: ";
410 LET ELL=MOD(SUMMA,11)
420 IF ELL=VAL(S$(11:11)) THEN
430   PRINT S$(11:11)
440 ELSE
450   PRINT "hibas"
460 END IF
470 PRINT :PRINT "bill. nyomasara indul"
480 IF INKEY$="" THEN 480
490 RUN
500 DEF BEVITEL
510   PRINT "Szemelyi szam:"
520   PRINT AT 9,15:S$;"? "
530   LET Q$=INKEY$:LET H=LEN(S$)
540   IF Q$=CHR$(13) AND H=11 THEN 600
550   IF H=11 AND(Q$<>CHR$(164) AND Q$<>CHR$(184)) THEN 530
560   IF H>0 AND(Q$=CHR$(164) OR Q$=CHR$(184)) THEN LET S$=S$(1:H-1)
570   IF Q$>="0" AND Q$<="9" THEN LET S$=S$&Q$ ! csak szamot fogad el
580   PRINT AT 9,15:S$;" "
590   GOTO 520
600   PRINT AT 9,15:S$;" ":PRINT
610 END DEF
620 DATA januar,31,februar,28,marcius,31
630 DATA aprilis,30,majus,31,junius,30
640 DATA julius,31,augusztus,31,szeptember,30
650 DATA oktober,31,november,31,december,31

Ez a megoldás a személyi szám további elemzése során egyszerűsíti a vizsgálatokat.

A számítógép beépített botkormánya a kurzor mozgatására szolgál. A nagyobb igénybevételnek ne tegyük ki. A játékokhoz jobb a külső - erőteljesebb kialakítású - botkormányt használni. Ha nem a saját botkormányt csatlakoztatjuk, hanem valamilyen más típusút, akkor ismernünk kell az Enterprise CONTROL port csatlakozójának kiosztását. A bekötés elvégzéséhez segíthet a 18. ábra.

A saját botkormányt programfutás közben különböző célra használhatjuk fel, állapotát többféle módon kérdezhetjük le. A beépített botkormány állapota lekérdezhető. A=JOY (0) értékadó utasítással. Minthogy a botkormány a billentyűzethez tartozik, a billentyű lekérdezhető INKEY$-vel is, ahol most a botkormány állását A$-be olvashatjuk be. De a billentyűzet elérhető a portról is 181dec (B5H) címen.
A botkormány állapotot a billentyűmátrix 7. sorából beolvasott 1., 2., 3. és 5. bit jelzi:
A különböző módon beolvasott botkormány állások:

Ezek felhasználásával egyszerű rajzoló programot írhatunk. A program tegye lehetővé a pont mozgatását a botkormány által kiválasztható nyolc irány bármelyike felé egészen a képernyő határáig, de a pont ne tudjon "lemászni" a képerny6r61. A botkormány és -a szóköz billentyű egyidejű lenyomása mellett az aktuális pozíción lévő pont radírozható legyen. A kitűzött feladat megoldására mutat egy lehetséges megoldást a 76. program.

100 ! botkormannyal rajzol
110 GRAPHICS :LET X=640:LET Y=340
120 SET KEY CLICK OFF
130 SET STATUS OFF
140 SET PALETTE BLACK,WHITE
150 PLOT X,Y;
160 LET A=JOY(0)
170 IF (A=2 OR A=6 OR A=10 OR A=18 OR A=22 OR A=26) AND X>0 THEN LET X=X-4
175 IF (A=1 OR A=5 OR A=9 OR A=17 OR A=21 OR A=25) AND X<1200 THEN LET X=X+4
180 IF (A=4 OR A=5 OR A=6 OR A=20 OR A=21 OR A=22) AND Y>0 THEN LET Y=Y-4
185 IF (A=8 OR A=9 OR A=10 OR A=24 OR A=25 OR A=26) AND Y<710 THEN LET Y=Y+4
190 SET INK(-1*(A<15)) ! szokoz billenytuvel egyutt radiroz
200 IF INKEY$="w" THEN RUN ! ujrainditas
210 GOTO 150

A 170-185. sorok hatása a LET-nél tárgyalt értékadási lehetőség felhasználásával egyszerűbben is megoldható (77. program).

100 ! botkormannyal rajzol
110 INPUT PROMPT "kezdopont x,y :":X,Y
120 SET STATUS OFF
130 GRAPHICS
140 SET PALETTE BLACK,WHITE
150 PLOT X,Y;
160 LET A=JOY(0)
170 !
175 LET X=X+4*(A BAND 2)*(X>O)-8*(A BAND 1)*(X<1200)
180 LET Y=Y+4*(A BAND 4)*(Y>O)-(A BAND 8)*(Y<710)
185 !
190 SET INK(-1*(A<15)) ! szokoz billenytuvel egyutt radiroz
200 IF INKEY$="w" THEN RUN ! ujrainditas
210 GOTO 150

A botkormány használatának egy igen hasznos és elegáns alkalmazási lehetősége a menütechnikára épülő programok egy-egy alprogramjának kijelölését biztosító alkalmazás. A 78. program lehetővé teszi, hogy a választási lehetőségeket kiíró listából a botkormány és a szóköz billentyű segítségével válasszuk ki a kívánt menüpontot.

1 PROGRAM "Menu.bas"
100 ! menubol valaszt botkormannyal
110 NUMERIC AA
120 CALL MENU
130 CALL VALASZTAS
140 ON AA GOTO 160,170,180,190,200,210,220,230
150 END
160 PRINT " 1. programresz":STOP
170 PRINT " 2. programresz":STOP
180 PRINT " 3. programresz":STOP
190 PRINT " 4. programresz":STOP
200 PRINT " 5. programresz":STOP
210 PRINT " 6. programresz":STOP
220 PRINT " 7. programresz":STOP
230 PRINT " 8. programresz":STOP
240 DEF MENU
250   SET STATUS OFF
260   CLEAR SCREEN
270   FOR Y=1 TO 8
280     PRINT AT Y*2+3,8:Y ". lehetoseg"
290   NEXT
300 END DEF
310 DEF VALASZTAS
320   LET K=5:LET K$=">"
330   LET P=JOY(0) ! menubol kijeloles botkormannyal
340   IF P>15 THEN 410 ! szokoz billentyuvel kivalaszt
350   IF P=8 AND K>4 THEN PRINT AT K,7:" ":LET K=K-2
360   IF K<5 THEN LET K=19 ! kijeloles "korbe forog"
370   IF P=4 AND K<20 THEN PRINT AT K,7:" ":LET K=K+2
380   IF K>20 THEN LET K=5
390   PRINT AT K,7:K$
400   GOTO 330
410   LET AA=(K-3)/2
420   CLEAR SCREEN
430   PING
440 END DEF

A botkormánnyal felfelé-lefelé mozgathatjuk a kijelölést láthatóvá tevő jelet. Ha megnyomjuk a szóköz billentyűt, akkor a program a választásnak megfelelő programágra ugrik az ON választás GOTO S1, S2, S3 utasítás hatására.

A változók értékadása az IS-BASIC-ben mindig kötelező. Nincs alapértelmezésű értéke semmilyen változótípusnak sem. Szerencsés lehetőséget biztosít az egy értékadó utasításban több változónak azonos értéket adó LET A, B, C=0 alakú utasítás. Ha azonban olyan eset adódik, amikor nagyon sok különböző nevű változónak kell értéket adni, akkor ez az eljárás nehézkes. Amennyiben az összes nagybetűs változónevet fel akarjuk használni, akkor a 79. program szerint olyan megoldást követhetünk, melynél a program elején az értékadó utasításban a változó nevét felülírva minden felhasznált változónak azonos értéket adunk.

100 FOR WW=65 TO 91
110   LET A=WW-1
112   ! " ez a valtozonev most a 4854. memoriacimen van
120   POKE 4854, WW
122   PRINT WW;
130 NEXT
140 PRINT A;B;C;D;E;F;G;Z
150 ! vigyazz ertekadas programfelulirassal!

Ehhez a trükkhöz így két dolgot nagyon alaposan végig kell gondolni.
A ciklusban történő értékadásnál, a listában most látható "A" változónév memóriabeli elhelyezkedését meg kell határozni, hiszen ha POKE-kal hozzányúlunk egy programsorhoz, akkor végzetes hibát is elkövethetünk. Az értékadást természetesen akár kétbetűs változónevek minden variációjára is elvégezhetjük a 80. program felhasználásával, de talán ilyen esetben már inkább (sőt lehet, hogy az előző példánál is) tömbváltozókat illik használni.

100 FOR I=65 TO 90
110   FOR J=65 TO 90
120     LET AA=0
130     ! ^ ez a karakter most 4872 memoriacimen van
140     ! ^ ez pedig most 4873 memoriacimen van
150     POKE 4872,I
160     POKE 4873,J
170   NEXT
180 NEXT
200 ! ketbetus valtozok alapertelmezese program felulirassal
210 ! osszesen 676 valtozonak ad erteket.

Ennek ellenére nézzük meg a 81. programban, hogy az ABC minden betűjével jelzett síringnek is lehet ilyen módon alap, vagy konkrét értéket adni.

100 FOR I=65 TO 91
110   LET A$="samu"
120   POKE 4853,1
130 NEXT
140 FOR I=65 TO 90
150   POKE 4938,1
160   PRINT CHR$(I);"$ =";A$
170 NEXT
180 ! idaig ugyanigy beirni ! ket helyen is felulirjuk a programot
190 ! futtatas elott akar ellenorizhetiuk a memoriacimeket es tartalmukat RUN 200-zal
200 FOR I=4827 TO 5000
210   PRINT I;PEEK(I)
220 NEXT

Ezt ugyan már láttuk, de ebbe a programban a változókat hasonló módon ki is listázzuk. Ebben az esetben már két helyen is benyúltunk POKE utasítással az eredeti programba. A programtárolás szabályait ismerők a program végén lévő ciklussal győződhetnek meg az átírandó memóriacímek helyességéről. Ezért ha beírtuk a programlistát, először RUN 180-nal indítsuk azt el és ha a címeink helyesek, akkor próbáljuk ki élesben azt. A feltételhez kötött értékadásnál használhatunk IF utasítást, pl.:
IF V=1 THEN LET A=3. Van egy elegánsabb, de esetenként 10%-kal lassabb végrehajtási idejű értékadási lehetőség is, az előző példánál maradva:

LET A=-3*(V=1)

Ezzel az értékadási móddal többször találkozhatunk. A zárójel tartalmát egyenlőség (igazság) szempontjáról ellenőrzi a rendszerprogram. Ha igaz, akkor logikailag igaz és 1 értéket kap a zárójelben lévő kifejezés. Ha nem igaz, akkor értéke 0 lesz.

A rajzok, színek képernyőn való találkozásának egymás felülírásának módját határozza meg ez a video feltétel. A fekete-fehér képernyőn is látványos képet kaphatunk a vonalak kizáró, vagy (XOR) módban való találkoztatásával. A 82. program sakktáblaszerű beosztást rajzol a képernyőre.

1 PROGRAM "Racs.bas"
100 ! racs
110 GRAPHICS
120 SET PALETTE BLACK,WHITE
130 FOR Y=0 TO 719 STEP 120 ! vizsyintes vonalak
140   FOR X=0 TO 1279 STEP 4
150     PLOT X,Y;X,Y+60
160   NEXT
170 NEXT
180 SET LINE MODE 3 ! ahol van ott torolj
190 FOR X=0 TO 1279 STEP 128 ! fuggoleges vonalak
200   FOR Y=0 TO 719 STEP 4
210     PLOT X,Y;X+64,Y
220   NEXT
230 NEXT
240 FOR R=10 TO 330 STEP 30
250   PLOT 640,360,ELLIPSE R,R
260 NEXT

Ezt a parancsot gyakran használjuk programunk írása közben. Az elkészült programot nyomtatóra is kiírathatjuk az LIST paranccsal. Sokszor jó lenne, akár a program futása közben egy-egy programsort kiírni a képernyőre, vagy az elkészült programról több listát készíteni a nyomtatón. A LIST (LLIST) kulcsszót viszont azokhoz a kulcsszavakhoz hasonlóan, melyek típusjelzőjének első bitje 0, nem veszi fel a tokenizáló rutin a programba, hanem hibajelzést ad. Amennyiben a kulcsszót, mint utasítást be tudjuk csempészni a programba, akkor azt végre fogja hajtani. A 83. programot úgy állíthatjuk elő, hogy először beírjuk a 130 PRINT programsort, majd azonnal kézből, parancsmódban végrehajtatjuk a POKE 4832,42 parancsot.

100 ! LIST programban
110 FOR I=1 TO 5
120   PRINT I; ".lista"
130   LIST
140   PRINT
150   IF INKEY$="" THEN GOTO 150
160 NEXT

Megtehetjük ezt (és csak akkor tehetjük meg, ha NEW után 0. programban vagyunk), mert az első beírt programsor a 4827dec memóriacímen kezdődik, a kulcsszó sorszáma pedig a tárolt programsor 6. byte-ja. Ott most a PRINT tokenje (56dec) helyezkedik el.
A POKE felülírja az ezen a címen lévő értéket, ha 42dec értéket írunk be, akkor a LIST kulcsszóra. Ezek után már "felöltöztethetjük" a programot a közölt lista szerint, majd futtathatjuk és végre fogja hajtani most már az így programban beépült LIST utasítást.
Nyilván hasznosabb lenne a nyomtatóra kiírni a programot. Ilyenkor a javasolt megoldás:
Készítsük el azt a programot, amit ki akarunk listázni a nyomtatón. Ha készen van, RENUMBER utasítással hozzuk rendbe a sorszámokat. Írjuk most már elé a 84. programot.

1 POKE 4865,82
2 FOR I=1 TO 2
3   PRINT 100
4   LPRINT :LPRINT
5 NEXT
6 ! a korabban beirt 100 sorszamon kezdodo program kilistazasa
100 REM igazi program kezdete

Amennyiben a program egy tetszőleges helyén kívánjuk ezt a trükköt alkalmazni, akkor is hasonló eljárást alkalmazhatunk. Írjuk meg a programot 0-ként és az ominózus sorba írjuk be a PRINT kulcsszó után a megkívánt LIST, vagy LLIST utáni szintaktikával a kívánt teendőt. Valahogy így:

n PRINT FIRST TO LAST
n PRINT 100-120
n PRINT eljárás

A teendőnk most az adott sorszámú sor memóriabeli helyének megkeresése és ebben a sorban a 6. byte értékének felülírása
82-re, ha a nyomtatóra,
42-re, ha a képernyőre
akarjuk a listát kiíratni. Írjuk be valamelyik szabad program helyére a 85. programot.

100 ! 0. programban atiras, EZT 2. FROGRAMKENT KELL BEIRNI ! ! !
110 INPUT PROMPT "melyik sorban: ":N
120 INPUT PROMPT "I=LIST 2=LLIST ":V
130 IF V<1 OR V>2 THEN 120
140 LET X=-42*(V=1)-82*(V=2)150 LET K=4827 ! a 0. program valtozatlanul ezen a címen kezdodik
160 DO
170   LET H=PEEK(K) ! a sor elso byte-ja a sorhosszat adja
180   IF PEEK(K+1)+256*PEEK(K+2)=N THEN EXIT DO ! megtalalta a keresett sorszamot
190   IF PEEK(K+H)=0 THEN EXIT DO ! megtalalta a program veget, de a keresett sorszamot nem
200   LET K=K+H ! kovetkezo sor eleje
210 LOOP
220 IF PEEK(K+1)+256*PEEK(K+2)<>N THEN GOTO 270
230 LET CIM=K+S ! a modositando byte:K->sor hossza, K+I->skatulyazas melysege,K+2->sorszam also-,
231 ! K+3->sorszam felsobyte, K+4->kulcsszo bevezeto (96),K+5-> kulcsszo token
240 POKE CIM, X
250 PRINT "elso program modositva"
260 END
270 PRINT "ilyen sorszara nincs"
280 END

Ezt a segédprogramot más célra is felhasználhatjuk. Az inputként közölt programsorszám ismeretében az adott sor memóriabeli elhelyezkedésére máskor is szükség lehet. Igaz a haladók RST 10 rutin segítségével hamarabb is megtalálhatják a keresett sor elejét, mint ahogy azt a GOTO, GOSUB rutinok végrehajtása közben végzi a számítógép rendszerprogramja is. Ez a program most lehetővé teszi, hogy az INPUT utasításként közölhető sorszámú sorban a sorszámot követő első kulcsszó tokenjét lecserélje a LIST, vagy LLIST kulcsszó tokenjére. A módosított 0. programhoz az EDIT 0-val térhetünk vissza.
A programba utólag becsempészett karakterek ravasz dolgok megvalósítását teszik lehetővé. Így pl. megtehetjük azt, hogy beírjuk a 86. programot, mellyel elérhetjük minden kezdő, középhaladó programozó vágyát, hogy saját Basic programját listázás ellen védje.

100 ! program titkositas, LIST letiltas
110 POKE 4833,0
120 PRINT "samu"
130 PRINT
140 PRINT
150 PRINT
160 PRINT
170 FOR I=4827 TO 4850
180   PRINT I;PEEK(I)
190 NEXT

Amennyiben a program listázása közben olyan helyen talál nullát az interpreter a programban, ahol azt nem várta, akkor azt programvégnek tekinti. Így csak az a dolgunk, hogy az első sorban a REM utáni kötelezően szóköz karakter helyére becsempésszük a 0-t.
Variálhatjuk ezt a védelmet úgy, hogy a sorszám és az első utasítás se látszódjék, ilyenkor a kulcsszó után kurzor visszaléptető karakterek kódját kell beírni annyiszor, hogy e szöveg elé kerüljünk. Erre ad ötletet a 87. program.

100 ! 12345(c) ENTERPRISE!
110 !^ ez 4833 cimen ^ ez pedig 4852 cimen van
120 !
130 !
140 ! program LIST letiltas, elso sort sem irja ki
150 !
160 !
170 FOR I=4833 TO 4837
180   POKE I,164
190 NEXT
200 FOR I=0 TO 30 STEP 3
210   PRINT TAB(15+14*SIN(I));"ENTERPRISE"
220 NEXT

Az első megjegyzés sorba az öt pont helyére tölti a rövid kis ciklus a CHR$(184) kurzor visszamozgató kódokat, majd a (c) szöveg után egy álprogramvég jelzés kerül a sorvégén lévő felkiáltójel helyére. Így ez a program sem árul többet el magából a listázás hatására. A program természetesen továbbra is él, futtatható és SAVE, LOAD parancsokkal menthető és tölthető. Viszont az egyszerű LIST parancsra nem sokat árul el magáról. A haladók viszont tudják, hogy becsaphatjuk ezt a lista védelmet úgy, hogy LIST sorszám utasítással átlépjük a védelmet biztosító sort, vagy egyszerűen töröljük ezt a programsort. Hogy megkeserítsük annak az életét, aki ki a akarja törölni az első helyen lévő n sorszámú programsorunkat, készítsünk olyan sorszámot, amit nem lehet átírni. Ez a programsorszám a 0. Igaz ilyet beírni sem lehet, de ha már egyszer van ilyen sor, akkor az él a programban. Szinte sejteni is lehet már a megoldást. Írjuk be a 88. programot.

100 ! marpedig ilyen sorszam nincs
110 ! az elso sor sorszarra a 4828/29 dec címen van
120 POKE 4828,0 ! ezt atirjuk 0. sorszamra
130 PRINT "nocsak": PRINT "lassuk a listat:"
140 LET VELE=PEEK(566)+256*PEEK(567) ! a beirt program vege utanra mutat
150 POKE VELE-3,42 ! az utolso, egy utasitast tartalmazo programsorban az utasitas tokenjenek atirasa
160 PRINT

A program futtatása után megdöbbenve láthatjuk, hogy 0. sorszámot is tartalmaz a programunk. Ezt a sort sem 0, sem DELETE 0, sem a RENUMBER nem bántja. Igaz ezt a sort a DELETE FIRST parancs el tudja intézni. Akkor keressünk erre a listázás tiltásra valami tökéletesebbnek tűnő megoldást.
Mint láttuk a LIST végrehajtását a végrehajtás során a 0. szegmens elején lévő ugrócímtáblán keresztül biztosítja a rendszerprogram. Írjuk át tehát ezt a címet, legalább annyira, hogy a LIST, LIST sorszám parancsot ne hajtsa végre a számítógép. Ennek egy járható útja, hogy programunkba beírjuk, vagy gépünknek parancsban kiadjuk a POKE 3813,16 utasítást. Természetesen jó, ha legalább mi magunk tudjuk, hogy visszaállítható az eredeti ugrócímtábla-beli érték és a LIST parancs hatása, ha az alapértelmezést visszaállítjuk POKE 3813, 121 segítségével.

Ez a függvény az argumentum természetes alapú logaritmusát adja. Ennek a jelölése a matematikában az ln. A logaritmus számítás alapszáma az e. Ez az érték nem található meg konstansként letárolva a számítógép memóriájában, igaz az EXP (1) függvény kiszámítása után az eredmény az e, a természetes logaritmus alapszáma. Ezt az értéket a matematikusok az alábbi formulával definiálták:

Számítógépünk 10 jegy pontossággal tudja kijelezni az értékeket, így nekünk sem kell a végtelenségig folytatni az összegzést. A 89. program 12 lépésben mutatja a közelítés egyre pontosabb értékeit és végül összehasonlítja a számítógép által nyújtott értékkel.

100 ! term log alapszama
110 LET E=1:LET F=1
120 FOR I=1 TO 12 !.kozelites 130 LET F=F*I
140   LET E=E+1/F
150   PRINT E
160 NEXT
170 PRINT
180 PRINT EXP(1) !kontroll kiiratas

De mi van akkor, ha valami oknál fogva több tizedesjegy pontossággal kívánjuk kiíratni az e értékét? Ilyenkor a string matematikához kell folyamodni. A string matematika alkalmazásával tetszőlegesen sok jegyen tudunk elvégezni összeadást, kivonást. Ez a tetszőlegesen sok jegy, ha az adatokat egy stringben kívánjuk tárolni, természetesen csak a maximálisan ábrázolható, tárolható string hosszával megegyező lehet.
Ha belegondolunk, hogy mit jelent tíz jegy pontosság, akkor láthatjuk, hogy a Föld átmérőjét centiméter pontossággal le tudjuk írni vele. A Föld-Nap távolság milliméter pontossággal való leírásához 26 számjegyet kellene leírni. Ennek ellenére tűzzük ki magunk elé, a harminc jegyig való összeadást. A 90. program A$ és B$ stringben kell beírnunk az összeadandó számjegy sorozatokat.

1 PROGRAM "Osszead.bas"
100 ! Osszeadas max 30 jegyre
110 LET N$="                 "
120 TEXT :LET F=0:PRINT :PRINT :PRINT
130 INPUT PROMPT "1. tag: ":A$
140 LET B$=A$
150 CALL ELEMZES
160 IF F=1 THEN GOTO 120
170 LET F=0
180 INPUT PROMPT "2. tag: ":B$
190 CALL ELEMZES
200 IF F=1 THEN 180
210 LET A$=N$&A$:LET B$=N$&B$
220 LET A$=A$(LEN(A$)-30:LEN(A$)) ! helyi erteknek megfeleloen egyforma hosszura alakitja a stringeket
230 LET B$=B$(LEN(B$)-30:LEN(B$))
240 PRINT AT 10,5:A$
250 PRINT AT 11,4:"+"&B$
260 PRINT AT 12,4:"--------------------------------"
270 FOR I=31 TO 1 STEP-1
280   LET E=VAL(A$(I:I))+VAL(B$(I:I))+F ! helyiertekek szerint osszead atvitel figyelembevetelevel
290   IF E>9 THEN
300     LET F=1:LET E=MOD(E,10) ! ha atvitel van
310   ELSE
320     LET F=0 ! osszeadasnal atvitel nem keletkezett
330   END IF
340   PRINT AT 13,4+I:STR$(E)(1:1)
350 NEXT
360 FOR I=1 TO 35
370   PRINT £102,AT 13,I:; !kepernyon vizsgalat
380   GET £102:X$
390   IF X$>"0" THEN EXIT FOR
400   PRINT AT 13,I:" " ! amig helyi ertekpotlo nullakat talal azokat torli
410 NEXT
420 END
430 DEF ELEMZES ! csak szamjegyeket tartalmaz a karaktersorozat?
440   LET H=LEN(B$)
450   IF H>30 THEN LET F=1
460   FOR V=1 TO H
470     IF B$(V:V)<"0" OR B$(V:V)>"9" THEN LET F=1
480   NEXT
490 END DEF

Az elemzés megvizsgálja, hogy valóban, számjegyeket és csak számjegyeket tartalmaznak-e a síringek.
A két összeadandó számjegy sorozatot helyi érték szerint helyesen írja egymás alá a program. Meg kell ezt tenni nemcsak a kiírás kedvéért, hanem azért is, hogy valóban azonos helyi értékű számjegyeket adjunk össze. A két string egyforma hosszát azzal biztosíthatjuk, hogy az A$, ill. B$ stringek elé ragasztunk harminc helyi érték pótló nullát. Majd a számsor vége felől számolva a harmincadik jegyen túliakat elhagyjuk. Az összeadást sorban, jegyenként elvégezzük az átvitel figyelembevételével. Így a számítógépnek mindig csak egy-két számjegy hosszúságú adatokkal kell dolgoznia, igaz az eredményként leírt számjegyek továbbra is csak egy string részét képezik. Az eredménystring számmá a szokásos VAL függvénnyel csak úgy alakítható át, hogy abban csak tíz számjegy és a hatványkitevő marad meg.
A program tartalmaz még egy érdekességet. Az eredmény értékes számjegyei előtt helyi érték pótló nullák sora éktelenkedik, márpedig ezekre nincs szükségünk. Ezeket a nullákat a képernyőről, programból letörölhetjük. Az eredmény sorát balról jobbra haladva - a képernyőn lévő karakterek vizsgálatával - elemezzük és mindaddig, amíg értékes számjegyet nem találunk, addig töröljük a képernyő adott pozícióján található karaktert. Minthogy az e kiszámításánál szorzásra, ill. osztásra is szükség van, nézzük meg a tetszőleges pontosságú osztás blokkdiagramját (19. ábra).

A gondolatmenet alapján megvalósított osztó programot a 91. program szemlélteti.

1 PROGRAM "Osztas.bas"
100 ! osztas akarhany szamjegyig
110 INPUT PROMPT "Hany szamjegyig szamoljon? ":N
120 INPUT PROMPT "osztando: ":A
130 INPUT PROMPT "oszto: ":B
140 IF B=0 THEN 130 ! nullaval nemosztunk!
150 PRINT STR$(INT(A/B))&"."; ! egeszresz es tizedespont kiirasa
160 GOTO 180
170 PRINT STR$(INT(A/B));
180 LET A=10*MOD(A,B) ! az osztando a maradek tizszerese
190 LET N=N-1 ! hol tartunk az osztasban
200 IF N>0 THEN 170
210 PRINT
220 END

Ennyi előismeret után már nekiláthatunk az e értékének kiszámításához. Azonban vegyük észre, hogy a tagok egymás után igen egyszerű szabállyal előállíthatók az előzőből. A nevezők rendre faktoriálisukat tartalmaznak:

(n+1)! = n!*(n+1).

A fentiek alapján követhető a feladat megoldásának menete a 92. program kapcsán.

1 PROGRAM "E.bas"
100 ! e kiszamitasa string matek
110 LET S$="0000000000000000000000000000000000"
120 LET B$=S$:LET E$="":LET A$="1"
130 FOR N=2 TO 33
140   CALL OSZTAS
150   CALL OSSZEADAS
160   PRINT "2.";B$(2:37)
170 NEXT
180 END
190 !
200 DEF OSZTAS
210   LET M=0:LET E$=""
220   FOR I=1 TO 37
230     LET A=10*M+VAL(A$(I:I))
240     LET E=INT(A/N):LET E$=E$&STR$(E) ! eredmeny i. szamjegye
250     LET M=MOD(A,N) ! a maradek
260   NEXT
270   LET A$=E$
280 END DEF
290 !
300 DEF OSSZEADAS
310   LET F=0 ! atviteljelzo
320   FOR I=37 TO 1 STEP-1
330     LET E=VAL(E$(I:I))+VAL(B$(I))+F
340     IF E>9 THEN
350       LET F=1:LET E=MOD(E,10) ! atvitel keletkezett az osszeadasnal
360     ELSE
370       LET F=0
380     END IF
390     LET B$=B$(1:I-1)&STR$(E)&B$(I+1:37)
400   NEXT
410 END DEF
420 ! e= 2.718281828459045235360287471352662481