TARTALOMJEGYZÉK

A könyvben szereplő programok egy része:

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+32 768)/65 536 - ö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 vizsgalathoy 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

A 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 0 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 l. 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 45o-ra 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 240. 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,250,ELLIPSE 250,250,PAINT
140 SET INK RGB(0,1,0) ! zold
150 PLOT 770,250,ELLIPSE 250,250,PAINT
160 SET INK RGB(1,1,0) ! sarga
170 PLOT 640,200,ELLIPSE 250,250,PAINT
180 SET INK RGB(0,0,1) ! kek
190 PLOT 640,480,ELLIPSE 250,250,PAINT
200 SET INK RGB(0,1,1) ! cyan
210 PLOT 700,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); ! 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) ! 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) ! 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) ! a pufferbe gyujtott 32fő 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 "Koralyno.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 128ason. 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-b61 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
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 IF R<4 AND K<70 THEN GOTO 200
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.

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 j6 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. 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öztiit 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.
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))) ! 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övetkezd 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>O 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>O 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

Természetesen a normál számítások elvégzéséhez bőven elegendő a számítógép nyújtotta tíz jegy pontosság. Az ilyen pontosságú számolást az Enterprise elvégzi. Ez a számítógép igen sok területen a hagyományos gondolkozást, matematikai ismeretek alkalmazását teszi lehetővé. Így a korábbi géptípusoktól eltérően lehetőséget biztosít a tízes alapú logaritmus használatára is. Igen érdekes az a Basic-ban közölt, de az 1. szegmens C8A4 címen megtalálható rutin, ami előállítja az X szám tízes alapú logaritmusát.

1 PROGRAM "Log.bas"
100 ! tizes alapu logaritmus x az 1. szegmens C8A4h rutin BASIC megfeleloje
110 INPUT PROMPT "x= ":X
120 LET W=X:LET S=SQR(10)
130 IF X>0 THEN 160
140 PRINT "Ervenytelen argumentum"
150 END
160 LET K=0:LET O=.1
170 IF X<=S AND X>S/10 THEN 220
180 IF X>S THEN LET O=10
190 DO UNTIL X<=S AND X>S/10
200 LET X=X/O:LET K=K-(O=10)+(O=.1) ! karakterisztika meghatarozasa, mantissza koncertalasa
210 LOOP
220 LET A=(X-1)/(X+1)
230 LET C1=-.6735816014 ! konstansok a RST10/92 alapjan
240 LET C2=3.163034915
250 LET C3=-2.915681437
260 LET C4=-8.190800454
270 LET C5=16.9669814
280 LET C6=-10.07040695
290 LET C7=.8685889638
300 ! log sorfejtes kozelitese
310 LET A1=((C1*A^2+C2)*A^2+C3)*A^2
320 LET A2=((A^2+C4)*A^2+C5)*A^2+C6
330 LET E=(A1/A2+C7)*A
340 PRINT "lg(";X;")= ",E+K
350 PRINT "az eredieti rutinnal",LOG10(W)
360 RUN

A 93. program lépéseit követve egy igazi matematikus bizony rosszallóan csóválná a fejét, de ezt majd minden Enterprise által megvalósított végtelen sor összegzésnél megteheti. Az argumentumokat egyrészt mindig úgy alakítja, módosítja, konvertálja, hogy azok egy jól behatárolható intervallumba kerüljenek. Ezekre az aránylag szűk, mindenesetre a lehetséges argumentum tartományához képest igen szűk tartományra azután olyan közelítő konstansokkal végzi el a sor összegzést, hogy a 10 értékes jegy pontosságot garantálni tudja. A RST 10/92 konstanstáblából nyeri a konstansokat, amelyek közül némelyik 3-4 tizedesjegyig, valamelyik korrekt matematikai értéket képvisel, a többi számjegy már nem az osztás várt eredménye, hanem a tartomány és a számítás kedvtért módosított érték.

A számítógép Neumanni ismérve között szerepel az is, hogy a gépnek logikai műveletek végzésére is alkalmasnak kell lennie. Az Enterprise ezen a területen is elkényezteti a felhasználót. Lehetőséget kínál logikai, valamint bináris ÉS, VAGY, TAGADÁS műveletének elvégzésére.
A logikai műveleteket többféle módon használhatjuk fel programjainkban. Vegyük pl. az AND logikai összefüggést! Használhatjuk feltétel vizsgálatok összekapcsolására:
ha az egyik feltétel igaz és a másik is igaz, akkor...
azaz

IF A=B AND C=5 THEN...

Itt a két feltétel igazságértéke (-1 ha igaz, 0 ha hamis) alapján az összekapcsolt ítéletek igazságértőkét határozza meg és ha igaz, akkor végrehajtja a sor további részét. Felhasználható értékadásra is, pl.:

A=(B AND C)

alakban, azonban ez csak akkor ad értelmes használható értéket, ha B és C 0 vagy -1 igazság értéket reprezentál. Ha a zárójelben 0-tól eltérő értékek vannak, akkor A=C értékadást végez. A bináris ÉS kapcsolat bitenkénti megegyezőséget vizsgál és eredményként az azonos biten 1 érték esetén ad 1-et.

             14  1110

BAND   7   0111

              6   0110

A vagy, ill. tagadás műveletét is vizsgálhatjuk hasonló gondolatmenet szerint.
A logikai műveletek összekapcsolhatók, de vannak olyan gyakran előforduló logikai műveletek, melyek önálló névvel rendelkeznek. A nagyobb számítógépek ezeket a logikai műveleteket is képesek egy kulcsszó segítségével elvégezni. Ne irigykedjünk, hiszen a három alap logikai művelet segítségével minden logikai kapcsolat és igazságtáblázatuk felírhatók. Ennek megvalósítását mutatja a 94. program.

1 PROGRAM "Logika.bas"
100 ! logikai muveletek
110 CLEAR SCREEN:PRINT :PRINT
120 PRINT "1. tagadas (NOT) A NOT A"
130 PRINT "2. es (NOT) A AND B"
140 PRINT "3. vagy (OR ) A OR B"
150 PRINT "4. kizaro vagy A XOR B"
160 PRINT "5. ekvivalencia A EQV B"
170 PRINT "6. implikacio A IMP B"
180 PRINT :PRINT "Melzik igazsagtablajat?"
190 LET V$=INKEY$&" "
200 LET V=VAL(V$)
210 IF V<1 OR V>6 THEN 190
220 LET L$=" £ £ ££"
230 LET J$=" £ £ £"
240 PRINT :PRINT
250 IF V=1 THEN
260 PRINT " A NOT A":PRINT "-------------"
270 FOR I=0 TO 1
280 PRINT USING L$:I,-1*(NOT(I))
290 NEXT
300 END IF
310 SELECT CASE V
320 CASE 1
330 CASE 2
340 PRINT " A B A AND B"
350 CASE 3
360 PRINT " A B A OR B"
370 CASE 4
380 PRINT " A B A XOR B"
390 CASE 5
400 PRINT " A B A EQV B"
410 CASE 6
420 PRINT " A B A IMP B"
430 END SELECT
440 PRINT "------------------"
450 FOR I=0 TO 1
460 FOR J=0 TO 1
470 SELECT CASE V
480 CASE 1
490 CASE 2
500 PRINT USING J$:I,J,(I BAND J)
510 CASE 3
520 PRINT USING J$:I,J,(I BOR J)
530 CASE 4
540 PRINT USING J$:I,J,(I BOR J)-(I AND J)
550 CASE 5
560 PRINT USING J$:I,J,-1*(NOT((I BOR J)-(I AND J)))
570 CASE 6
580 PRINT USING J$:I,J,(-1)*(NOT(I)) BOR J
590 END SELECT
600 NEXT
610 NEXT
620 PRINT
630 PRINT "Billentyu nyomasra tovabb"
640 IF INKEY$="" THEN 640
650 RUN