1 . Bevezetés
2. Az adatszerkezetek
2.1. Memóriatérkép
2.2 Programtárolás és tokenizálás
2.3. A Szimbólumtábla
2.4. A BASIC tár
2.5 Stringek (Karakterláncok)
2.6 Számok
3. Utasításbővítések
4. Függvénybővítések
5. A változók
6. Rendszerhívások

1. Bevezetés
A megalkotott IS-BASIC definiált, a RAM-ban jól ismert helyen elhelyezkedő táblázatokkal és mutatókkal támogatja az utasítás- és függvénybővítőket.
Lapszámozási szempontok miatt ezek a táblázatok és mutatók mindig az alsó 16 Kbyte-os szegmensen (a 0. lapon) helyezkednek el, de ezen a szegmensen korlátozott az adatmennyiség, s ugyancsak emiatt a bővítők aktuális kódjára mutató pointerek tartalmazhatnak szegmensszámot és címet is. Ez a cím mutathat egy ugyancsak a 0. lapon lévő kódra (például a kazettáról vagy lemezről betöltött bővítők esetében) vagy egy másik szegmensen lévőre (ROM-beli bővítőknél vagy egy EXOS rendszerbővítőnél).
Bármely függvény- vagy utasításbővítő elronthatja a Z80 regisztereket, az IX-et kivéve, amely mindig a változók elejére mutat.
Számos BASIC változó hasznos vagy szükséges lehet bizonyos bővítőknél, ezeknek csak a fantázianevükre hivatkozunk ebben a leírásban. Valódi címük az 5. fejezetben található (Változók).
A BASIC lehetővé teszi a bővítők számára sokféle rendszerhívás használatát, melyekre ugyancsak névvel hivatkozunk, részletes leírásuk a 6. fejezetben található (Rendszerhívások). Ezek a rendszerhívások teszik lehetővé a bővítők kompatibilitását a BASIC újabb vagy előző változataival.
A második fejezet (Adatszerkezetek) bemutatja a BASIC belső adatszervezési formáját, s íly módon ezek is használhatók lesznek a bővítők készítésekor. Egy függvénybővítőnek szüksége lehet pl. a BASIC-ben használatos decimális számok alakjára. Sok olyan rendszerhívás van, mely végrehajtva a szükséges műveletet, az esetek zömében szükségtelenné teszi a BASIC adatszerkezetéhez történő közvetlen hozzáférést.
A bővítők állhatnak egy ROM bővítő kódjából, vagy kazettán / lemezen lévő kódból.
ROM bővítő esetében a ROM-nak válaszolnia kell a "BASICX" karakterláncra, amelyet a BASIC küld körbe az inicializálás alatt. Ekkor a ROM-nak minden szükséges kódot át kell másolnia a 0. lapra az EXTOP által megjelölt címtől kezdve, el kell végeznie a szükséges inicializálásokat és be kell állítania az EXTOP, CURLOC és MCTOP változók értékét úgy, hogy azok a 0. lap következő szabad byte-jára mutassanak. Ezalatt csak a BASIC 0. lapja érhető el, így a ROM meg sem kísérelheti a felhasználói programba, a szimbólumtáblába vagy a tárba történő címzést, mivel azok még nem álltak föl. Hasonlóképpen a BASIC default (alapértelmezésű) csatornái sem álltak még föl. Ellenben a rendszer szimbólumtáblája és a kulcsszótáblája már inicializálódott az alapbelépések értékével, így azok változtathatók vagy növelhetők.
Azok a bővítők, amelyeket áthelyezhető modulként kazettáról vagy lemezről töltenek be, egy blokkban tartalmazzák a 0. lap információit és magát a kódot, s betöltésükkor a BASIC automatikusan helyet biztosít számukra a 0. lapon. Betöltésük után inicializálódnak, az inicializációs rutin relatív kezdőcímét a file fejléce tartalmazza (lásd az idevágó EXOS leírást), az FFFFH értékű relatív cím az inicializáló rutin hiányát jelöli (ez elég valószínűtlen BASIC bővítő esetében.
Azok a bővítők, amelyeket EXOS rendszerbővítőként töltünk be kazettáról vagy lemezről, a fent említett változókat nem állíthatják el. Ez a korlátozás áthidalható úgy, hogy a 0. lapra helyezendő információkat áthelyezhető modulként töltjük be közvetlenül az aktuális kódot és adatokat tartalmazó EXOS rendszerbővítő betöltése után.

2. Az adatszerkezetek
Ez a fejezet röviden bemutatja, hogyan kezeli a BASIC egyes adatszerkezeteit. Ha ezeket az információkat pontatlanul alkalmazzák vagy megváltoztatják, a BASIC megbízhatatlanná válik.

2.1. Memóriatérkép
A BASIC memóriatérképe lapozási szempontok miatt nem "egyenesen' épül fel. A legfelső szegmens (3. lap) mindig az éppen végrehajtás alatt álló kódot tartalmazza (kivéve ha a bővítők túlnyúlnak a 0. lapon). Rendszerint ez a BASIC fő (cartridge) ROM-ja, de a belső ROM második fele is lehet (amely kb. 8K BASIC-et tartalmaz), vagy egy ROM bővítés.
A BASIC beindítása után a 0. lap mindig ugyanazt a RAM szegmenst tartalmazza. Ebben a BASIC változói, a kulcsszótábla valamint a szimbólumtábla rendszerre vonatkozó része található. Ezek fölött helyezkedik el a program, a szimbólumtábla és a 0. program veremtára, amely átnőhet az 1., és 2. lapon lévő szegmensekbe. A további számú programok egy 1. lapon lévő szegmens elején kezdődnek és egy 2. lapon lévő szegmens végéig tarthatnak. A következőkben részletesen ismertetjük a 0. lap különböző területeit:

2.2 Programtárolás és tokenizálás
A program a RAM-ban tokenizált formában tárolódik. Az aktuális program elejére a TEXT változó mutat. Ez általában valamely, az 1. lapon elhelyezkedő szegmens eleje, a 0. lap viszont speciális eset, amely a 0. lap bármely részén kezdődhet.
A BASIC sorok formátuma:

A hosszbyte 0 értéke a program végét jelzi. A bekezdés-byte 0 és 127 közötti értéket vesz fel és az egymásba ágyazott blokkok mélységét adja meg, amelyben a sor található. Ez a számláló használatos mind a program futása, mind pedig a listázása alatt. A bekezdés-byte legfölső bitjét a BASIC belsőleg használja flagként.
A tokenizált programszöveg olyan elemek sorozatából tevődik össze, amelyek mindegyike megfelel az eredeti forrásszöveg különböző szintaktikus elemeinek.
Minden elem legalább egy byte-ból áll. Ez a byte írja le az elemet; az őt követő byte-ok (a következő elem kezdetéig) adatokat tartalmaznak. Tehát egy programsor a következőképpen nézhet ki:

Általában az elemet leíró byte két részre van osztva: a felső három bit az elem típusát írja le, az alsó 5 bit tartalmazza az elembeli byteok számát (egy kivétellel). A következőkben megadjuk az érvényes elemek listáját és formátumukat:

Lebegőpontos konstansok
A forrásprogramban lévő lebegőpontos számok nem ASCII-ben tárolódnak, hanem a belső BCD reprezentációjukban (lásd a 2.6 fejezetet (Számok) részletesebben) úgy, ahogy a szimbólumtáblában is (lásd a 2.3 fejezetet (Szimbólumtábla)).
Egy lebegőpontos szám leiróbyte-ja C6H értékű és a szám hat BCD byte-ja követi.

Egész konstansok
A 0 és 9999 közti egész számok a gyorsaság miatt nem lebegőpontos alakban tárolódnak, hanem a normál Z80 formátumban, 16 bites bináris számként.
Egy egész szám leíróbyte-ja C2H értékű és a szám két bináris byte-ja követi.

Sorszámok
A sorszámokat a tárolás során megkülönböztetjük az egész számoktól, így a RENUMBER felismeri, hogy mit kell újraszámozni.
Egy sorszám leíróbyte-ja A2H értékű és a szám két bináris byte-ja követi, mint az egész számok esetében.

String konstansok
A stringek aktuális karakterei ASCII-ben tárolódnak úgy, mint az eredeti forrásszövegben, de megelőzi őket a string hosszbyte-ja. A nyitó és záró idézőjelek nem tárolódnak a string részeként és a stringen belüli dupla idézőjelek ("") is szimpla idézőjelként kerülnek tárolásra (").
A string leíróbyte-ja 80H értékű, ezt. a string hosszbyte-ja követi (0 és 254 közti szám) továbbá a string aktuális ASCII karakterei.

Kulcsszavak
A kulcsszavakat olyan byte-ok képviselik, amelyek a kulcsszó kulcstáblában elfoglalt helyét, azaz kulcsszó-számát tartalmazzák (további részletek a 3. fejezetben (Utasításbővítések)).
A kulcsszó-leíróbyte 60H értékű és a kulcsszó-számot tartalmazó byte követi.

Azonosítók
Az azonosító elemek is szövegeket tartalmaznak, mégpedig olyanokat, amelyeket utasításokon belül használunk, mint például a TO a FOR utasításban, vagy a VIDEO MODE a SET utasításban. Az azonosítók nagybetűs ASCII karakterekkel tárolódnak, s a leíróbyte alsó 5 bitje a hosszt tartalmazza.
Az azonosító leíróbyte-ja 20H (numerikus) vagy 40H (string) értékű + az azonosítóban lévő karakterek száma (1 és 31 közti szám).

Jelek
A programokban megjelenő írásjeleket (mint pl. a <> és a ;) nevezzük 'jeleknek'. Ezek egy 0 és 31 közti számmá konvertálódnak, majd a leíróbyte alsó 5 bitjébe kódolódnak.
A jel-leíróbyte 0 értékű + a-jel tokenje. A használt tokenek:

2.3. A Szimbólumtábla
A szimbólumtábla a felhasználó változóit és függvényneveit, valamint a beépített függvényeket tartalmazza ASCII-ben. A tábla olyan pointerek 32-belépéses hash táblájából áll, amely a belépési pontok "láncára" mutat. Mindegyik belépés tartalmaz egy azonos hash értékű, következő belépésre mutató pointert, s a 0 értékű pointer jelzi a lánc végét.
Amikor egy azonosító adódik a szimbólumtáblához, a belépési pont bekerül a RAM-ba és a megfelelő hash tábla pointer az új belépésre állítódik. A régi hash tábla pointer azután az új belépési pont adatai közé kerül, így biztosítva azt, hogy az azonos nevű belépési pontok közül először az újat találja meg. Egy belépési pont és a további belépések egyszerűen elmozdíthatók a hash tábla pointer átállításával, így biztosítva a függvények számára azt a lehetőséget, hogy lokális változókkal rendelkezzenek.
A RAM-ban a belépések sorban egymás után helyeződnek el. A rekurzív függvényhívások miatt egy belépési pont soha nem emelhető ki anélkül, hogy a később definiált belépéseket is el ne mozdítanánk.
A VARPTR változó a szimbólumtábla következő szabad byte-jóra, a VARBASE pedig az első függvényváltozóra mutat. Amikor meghívnak egy függvényt, a VARPTR átmásolódik a VARBASE-be, s a függvény végrehajtása után a VARBASE és a VARPTR visszaállítódnak (hash táblával együtt), s így függetlenítik a függvény lokális változóit.
A hash tábla a HASHTAB-nál kezdődik és 32 db 16 bites pointert tartalmaz. Kezdetben ezek a 0. lapon elhelyezkedő beépített függvényekre mutatnak, de miután a felhasználó szimbólumai is bekerülnek a táblába, a 0. lapon túlra is mutathatnak. Így a szimbólumtáblából mindig ki kell törölni a felhasználói szimbólumokat, mielőtt új programszámra térnénk át.
A szimbólumtábla belépési pontjai a következőképpen épülnek fel:

A flag byte-ban a bitek jelentése a következő:

A szimbólum neve nagybetűs ASCII karakterekből áll, s a név előtt álló byte tartalmazza a névben szereplő karakterek számát. A string azonosítók a $ jellel végződnek.
Az adatokat és az általuk elfoglalt területet az azonosító flag-byte által leírt típusa határozza meg.
Ha az azonosító egy függvény hivatkozási paramétere, akkor a hozzátartozó adat egy olyan 16 bites pointert tartalmaz, amely a függvény azonosítójának a belépési pontjára mutat.
Ha az azonosító egy gépi kódú függvény, akkor az adatok első két byte-ja egy pointer, amely a függvény kódjára mutat; amely a 3. lapra kerül (bővítés esetében a 0. lapra). A következő byte a kód szegmensszámát tartalmazza vagy 0-át, ha a kód a 0. lapon van (mivel a szegmensszám előre nem meghatározható).
Ha az azonosító egy egyszerű (azaz nem vektor) numerikus vagy string változó, akkor a követkkező byte-ok magát a számot vagy a stringet tartalmazzák. További részletek a 2.5 (String) és a 2.6 (Számok) fejezetekben.
Ha az azonosító egy felhasználó által definiált numerikus vagy string függvény, akkor az őt követő byte-ok számot vagy stringet tartalmaznak (hasonlóan a fentebb leírt egyszerű változó esetéhez), s őket egy olyan 16 bites pointer követi, amely annak a sornak az elejére mutat, ahol a függvénynek megfelelő DEF vagy HAHDLER előfordul.
Ha az azonosító egy numerikus vagy string vektor, akkor az első adat információt tartalmaz a vektor dimenzióiról, valamint a fölső és alsó határairól.
Az első byte a vektor dimenziószáma (1 vagy 2), s az őt követő 6 byte-ban található a vektor összes elemének száma lebegőpontos formában (ahogy fentebb írtuk). Ezt követi az első dimenzióban érvényes alsó vektorhatár és a vektorelemek száma, mindkettő 6 byte-os, lebegőpontos formában. Mindezek megismétlődnek a második dimenzióra, ha létezik. Végül pedig numerikus vagy string elemek sorozata következik (az előzőekben leírt formában), mégpedig minden string elemhez egy. A második dimenzióban lévő elemek változnak a leggyorsabban a memóriában.

2.4. A BASIC tár
A BASIC a Z80 veremtárát a 0. lap egy rögzített helyén tartja, hogy elkerülje a lapszámozási problémákat, de van egy másik tára is, amelyet kifejezések kiértékelésekor használ számok és stringek tárolására, s amely információkat tartalmaz az éppen működő FOR..NEXT és DO..LOOP, GOSUB, WHEN blokkokról és függvényhívásokról. Ennek a tárnak a tetejére a STKPTR, az aljára a STKTOP változó mutat.
Amikor egy csatornanyitó EXOS hívás történik (beleértve a GRAPHICS és a TEXT utasításokat, stb.), a tár közvetlenül a szimbólumtábla fölé tolódik a memóriában és a fölöslegessé vált szegmensek visszaadódnak az EXOS-nak.
Mielőtt bármely adatot betenne a tárba, a BASIC ellenőrzi, hogy elég hely van-e a tár és a szimbólumtábla teteje között. Amennyiben nincs elegendő hely, a tárat föltolja az éppen használatos szegmens tetejére. Ha még így sincs elegendő hely, a BASIC lefoglal egy másik szegmenst, belapozza a soron következő legmagasabb, még használatlan lapra és áthelyezi a tárat ennek a szegmensnek a tetejére (vagy az EXOS határára, ha a szegmens már megosztott. Ha nincs több felhasználható szegmens vagy ha másik szegmens szükséges olyankor, amikor a legfelső használatban lévő szegmens már a 2. lapon van, "out of memory" hibajelzést ad.
Ez egy leegyszerűsített áttekintése annak a módnak, ahogy a BASIC mozgatja a tárat. Ezt tartsuk szem előtt akkor, amikor egy bővítő utasítás vagy függvény meghívja a kifejezés-kiértékelőt vagy a BASIC más részét, mivel előfordulhat, hogy egy kifejezés meghív egy felhasználói függvényt, az pedig a tár elállítódását okozhatja. Ha ez elkerülhetetlen, akkor elmentendő a STKTOP tartalmából a negatív offset és a BASIC hívása után az aktuális tárcímet újra kell számítani.
A tárban minden elemet megelőz egy őt leíró byte. A tárelem többi byte-ja adatokat tartalmaz. A tárelemek a következők:

1-es típus - Ez különleges alkalmakkor használható, egy különleges byte tárolására alkalmas.
1 byte - a tárolandó byte

2-es típus - Numerikus adat.
8 byte - a 2.6. részben leírt számformátum szerint.

3-as típus - String adat.
1 byte - hosszbyte
n byte - string

4-es típus - FOR-NEXT blokk
9 byte - kezdeti változó érték (szabályos numerikus tárelem formában)
9 byte - határ érték
9 byte - léptetési érték
2 byte - a FOR változó helye
2 byte - a NEXT sor címe a memóriában
2 byte - a FOR sor címe a memóriában

5-ös típus - DO-LOOP blokk
2 byte - DO sor címe a memóriában
2 byte - LOOP sor címe a memóriában

6-os típus
A tár 6-os típusa a GOSUB...RETURN tárelem, amit 2 adatbyte követ. Ez a 2 byte egy pointert tartalmaz, amely arra a sorra mutat, amelyik a GOSUB utasítást tartalmazó sort követi.

7-es típus
A tár 7-es típusa a DEF tárelem, amit 5 adatbyte követ. Ezek a következők:
2 byte - a VARPTR értéke, amikor meghívtuk a függvényt
1 byte - a 0. bit értéke 1, ha az eredményt a tárba kell tenni
2 byte - a VARBASE értéke, amikor meghívtuk a függvényt
Ez a tárelem használatos akkor is, amikor egy esetleges megszakítás eredményeképpen a HANDLER kerül meghívásra (aktív hibakezelő esetén).

8-as típus
A tár 8-as típusa a WHEH tárelem, amelyet a 2.0 verzióban 2 adatbyte követ. Ezek egy olyan pointert tartalmaznak, amely a következő külső hibakezelőre mutat (0 ha nincs ilyen). A 2.1 verzióban 8 adatbyte van, ezek a következők:
2 byte - pointer az END WHEH sorra.
4 byte - belsőleg használatos.
2 byte - WHEH blokk mélység számláló.

2.5 Stringek (Karakterláncok)
A szimbólumtáblában és a BASIC tárban tárolt stringek azonos formátumúak. Az első byte-ban a string karaktereinek a száma van (0 és 254 közötti szám), a string többi részében pedig a string tényleges karakterei tárolódnak tetszőleges számú byte-on. A szimbólumtábla belépési pontján található 255 értékű hosszbyte azt jelenti, hogy az azonosító nem inicializálódott.
A szimbólumtáblában minden string részére egy fix nagyságú hely biztosított. Ha a string hossza kevesebb, mint a részére lefoglalt byteok száma, akkor a string végén lévő maradék byte-ok szemetet tartalmaznak. A szimbólumtáblában a hosszbyte előtti byte tartalmazza a string maximális hosszát, azaz a fenntartott byte-ok számát + 1-et.
A BASIC tárban az elfoglalt byte-ok száma a string hossza + 2 (azaz még egy külön byte a hosszbyte és egy külön byte a tár típusbyte számára -lásd a fenti 2.4 fejezetet (BASIC tár)).

2.6 Számok
A szimbólumtáblában a számok 6 byte-os BCD alakban tárolódnak. A legalsó memóriacímnél lévő számpár a legkisebb helyiértékű számjegy. A szám fölső byte-ja tartalmazza a bináris kitevőt és előjelet, s a fölső byte alatt egy byte-tal helyezkedik el a legnagyobb helyiértékű számpár.
A tizedespont (normalizált számoknál) mindig a legnagyobb helyiértékű számjegy előtt helyezkedik el. A hatványkitevő 63-mal eltolódik negatív szám esetén, amikor a hatványkitevő-byte fölső bitje 1.
Ha a hatványkitevő-byte értéke 7F hexa, akkor a szám első és második byteja egy normál Z80 formátumú, előjeles 16 bites egészet tartalmaz, s a többi byte-ot használatlanul hagyja. A 0 szám is ilyen formátumban tárolódik.
A hatványkitevő-byte 7F hexa értéke és a legnagyobb helyiértékű byte-ok FF hexa (értelmetlen BCD) értéke azt jelenti, hogy a numerikus azonosító nem inicializálódott.
A BASIC tárban hasonló a formátum, azzal a kivétellel, hogy a legnagyobb helyiértékű számjegyeket tartalmazó byte és a kitevő között egy további byte található. Ez a byte az aritmetikai műveletek alatt használatos nagyobb pontosság elérése érdekében.
Ugyanígy, a legkisebb helyiértékű számjegyek byte-ja előtt is van egy további byte. Ez pedig a transzcendentális függvények kiszámítása alatt használatos, szintén a nagyobb pontosság érdekében.
A tárbeli számok a következőképpen néznek ki:

• ahol a jelöli a legnagyobb helyiértékű számjegyet, b a következő helyiértékű számjegy, stb.
• t a tipusbyte (lásd a fenti 2.4 (BASIC tár) fejezetet).
• se a hatványkitevő, a legfölső bitje a szám előjelét jelöli.

A BASIC esetenként egyenként is hivatkozik a számjegyekre, s a fenti táblázat fölötti számok ezen számjegyek BASIC által használt sorszámozását mutatják. A PUTDIG és GETDIG rendszerhívások használják ezt a sémát. (lásd részletesebben a 6. fejezetet (Rendszerhívások)).
Van néhány függvény, amely a számoknak egy más formáját használja további pontosság elérése. érdekében. Ez egyfajta keresztezése a szimbólumtáblában és a tárban használt formátumoknak. A fenti jelölés szerinti k és l számjegyek léteznek ebben a formátumban, ellenben a 0:0 számjegyek nem. Így ez az új formátum 7 byte-ot igényel. Egyes rendszerhívások (lásd részletesebben a 6. fejezetet (Rendszerhívások)) és változók (lásd az 5. fejezetet (Változók)) ezzel a formátummal dolgoznak.

3. Utasításbővítések
A BASIC a 0. lapon tárolja a kulcsszó-leírókra mutató pointerek összefűzött láncát és további szükség szerinti kulcsszavak felfűzését teszi lehetővé úgy, hogy új pointertáblát fűzünk a lánc eddigi utolsó tagja után. Lehetőség van arra is, hogy az alaptáblában megváltoztassunk pointereket úgy, hogy azok egy új leíróra mutassanak s ezáltal megváltoztassák vagy növeljék az alaputasítások hatását.
A táblák alakja a következő:

A láncolatban pointer a következő táblára mutató pointer 0 értéke a lánc végét jelzi. Ha a szegmensszám 0, ez azt jelenti, hogy a kulcsszám kódja a 0. lapon van.
A leíró maga (lásd később) mindig a 0. lapon kell, hogy legyen, habár az aktuális kód egy másik szegmensen is lehet. Ez alól az egyetlen kivétel a BASIC alapkulcsszavai képezik, amelyek a 3. lapon vannak, de a BASIC tudja, hogy a hozzáféréshez ezt mindenképpen be kell lapozni.
A kulcsszavak aktuális token értékét (lásd részletesebben a 2.2 fejezetet (Program)) a leíróra mutató pointer helyzete határozza meg a táblák láncolatában. Az első pointernek (amely a BASIC alapkulcsszavainak egyikére mutat) van a legalacsonyabb token értéke (0), s ez az érték minden újabb pointernél emelkedik.
Ajánlatos az új kulcsszótáblákat úgy felfűzni, hogy "az alaptáblában lévő következő táblára mutató pointert megváltoztatjuk oly módon, hogy az az új táblára mutasson, s utána az új táblában lévő pointert beállítjuk az alaptáblában lévő pointer eredeti, előző értékére. Ily módon az új kulcsszavak nem építhetnek arra, hogy fix token értékük van, hanem azt ki kell számolni, követve a kulcsszótáblák láncolatát.
Meg kell jegyezntünk, hogy több blokk-orientált BASIC kulcsszó nem követi ezt, hanem feltételezi, hogy a kulcsszótábla-listán rögzített helyet foglal el. Ezért nem célszerű az alaptáblát az első helyen hagyni a listában. Ez elkerülhető a fent említett módszerrel.
A fenti pointerek által meghatározott kulcsszóleírók (amelyek mindig a 0. lapon vannak) a következő formájúak:

A végrehajtási cím egy 3. lapra mutató pointer. Ezt hívja meg a BASIC az utasítás végrehajtásakor. A rutinnak abban a szegmensben kell elhelyezkednie, amelyet a fent leírt kulcsszópointer-tábla szegmensbyte-ja kijelöl.
A tokenizálási cím is egy pointer (hasonló az előbb említett végrehajtási cím pointerhez). Ez egy BASIC által hívott rutinra mutat, amely a sor begépelésekor kerül meghívásra, közvetlenül a sor tokenizálása után.
Ezt a bővítő utasítások nem nagyon használják, de hasznos lehet futtatás előtt a sor szintaxisának ellenőrzésére, hogy elkerüljék azt a zavart, ami az utasításokban használt kettőspont és a több utasítást elválasztó kettőspont használata során felmerülhet, valamint annak jelzésére, hogy ha egy utasításban előforduló szám valójában egy sorszám. Ez utóbbi azt biztosítja, hogy a RENUMBER korrektül számozza át ezt a számot is. A sorszámok belső reprezentációját a 2.2 fejezetben (Program) tárgyaltuk részletesen.
Tegyük fel például, hogy egy bővítő kulcsszava után közvetlenül egy sorszám áll (pl. GOTO n, GOSUB m, RESTORE p). A tokenizáló rutinnak először meg kell hívnia a GETITEM rendszerrutint azért, hogy a SYMB pointer a GETITEM által megadott sorszámra mutathasson. Az elemleíró byte értékét a (SYMB-1)-nél C2 hexa (egész szám) helyett A2 hexa (sorszám) értékre kell állítania. Ezután visszaadhatja a vezérlést a tokenizáló rutin. Ezt követően a RENUMBER későbbi használata során a sorszám átszámozódik. A fentiek kódolva:

A flag byte a benne lévő egyes bit flagekkel leírja a kulcsszót és azt, hogy az milyen kontextus alatt használható. A byte-ban lévő bitek jelentése a következő:

Ha a blokk-eleje-bit és a blokk-vége-bit is be van állítva, a BASIC feltételezi, hogy a kulcsszó egy "ideiglenes" vége a blokknak, és a bekezdésszámolót csak erre a sorra fogja csökkenteni. Ez történik pl. a CASE utasításnál.
A kulcsszó leíróbyte-ban az utasításnév rész nagybetűs ASCII-kódban tartalmazza a kulcsszó nevét. A név betűinek számát az őt megelőző byte tartalmazza.
Megjegyzendő, hogy amikor a kulcsszó végrehajtó rutin meghívódik, addigra a GETITEM rutin már meghívódott (lásd a 6. fejezetet (Rendszerhívások) és a 2.2 fejezetet (Program)), hogy megkaphassa a kulcsszót követő elemet a programsorban. Ez a tokenizáló rutinra nem érvényes.

4. Függvénybővítések
A függvénybővítők a leírójuk segítségével láncolhatók be, s ezeknek, akárcsak a kulcsszavaknál, a 0. lapon kell lenniük. Ebben az esetben a belépés első byte-jára mutató pointerrel hívódik meg a LINKSYM nevű BASIC rendszerhívás. Utána a BASIC kiszámolja a hash számot és hozzácsatolja a belépést a szimbólumtábla beépített részéhez. Akárcsak a kulcsszavaknál, az aktuális végrehajtó rutin akár egy nem a 0. lapon lévő szegmensen is lehet.
A szimbólumtábla belépése, amely a láncoláshoz kell a BASIC-nek, a következő:

Függvénybővítő esetében a flag-byte mindig 8 (numerikus) vagy 9 (string). Lásd részletesebben a 2.3 fejezetben (Szimbólumtábla).
A függvénynév a függvény nevét tartalmazza nagybetűs ASCII-ben, s őt megelőzi a névben előforduló karakterek számát tartalmazó byte. Karakterfüggvények neve '$'-ral kell, hogy végződjék.
A függvény kódjának meghívásakor még nincs kiértékelt paraméter. Hogy ez megtörténjék, végre kell hajtani a megfelelő rendszerhívásokat, mint pl. a P_NUM-ot (lásd részletesen a 6. fejezetet (Rendszerhívások)).
A végeredményt mindig a BASIC tárban kell hagyni, s természetesen az eredmény típusa meg kell hogy egyezzék a függvény típusával.
A függvénybővítők használhatják az X és Y lebegőpontos változókat (lásd részletesen az 5. fejezetben (Változók)), de megjegyezzük, hogy néhány transzcendentális függvény, amely rendszerhívásként is hívható, szintén használja ezeket. Lásd részletesebben a 6. fejezetben (Rendszerhívások).

5. A változók
A következőkben megadjuk a könyvben használatos BASIC változók fantázianeveit (mnemonikjait) címcikkel és szerepükkel együtt.

DEGRAG (201 hexa, 513 decimális)
Ennek a byte-nak a 0. bitje 1 értékű, ha az OPTION ANGLE DEGREES aktív, azaz a szögeket fokokban számolja.

SYMBTYPE (202 hexa, 514 decimális)
Ez a byte tartalmazza a GETITEM rendszerhívás által utolsóként beolvasott elem szimbólumtípusát. lásd részletesebben a 6. fejezetben (Rendszerhívások)

SYMBLEN (203 hexa, 515 decimális)
Ez a byte tartalmazza a GETITEM rendszerhívás által utolsóként beolvasott elem hosszát. Lásd részletesebben a 6. fejezetben (Rendszerhívások)

SIGNIS (204 hexa, 516 decimális)
Ez a byte tartalmazza a GETITEM rendszerhívás által utolsóként beolvasott elem jeltípusát. Lásd részletesebben a 6. fejesetben (Rendszerhívások).

STMTEND (206 hexa, 518 decimális)
Amikor egy utasítás végrehajtó rutinja meghívódik, ez a byte 0 és a legtöbb bővítő utasítás meg is hagyja 0-nak. Ez azt okozza, hogy a végrehajtási rutinból történő visszatérés után a BASIC megvizsgálja, hogy ez többutasításos sor-e, s ha igen, végrehajtja a következő utasítást. Ha a byte 1-re van állítva, a BASIC ehelyett a sor végét fogja ellenőrizni és hibajelzést ad, ha nem azt találja. Ha 2-re van állítva,, a BASIC nem fog ellenőrizni semmit, hanem egyszerűen elkezdi az aktuális sort követő sor végrehajtását. Ha 3-ra van állítva, a BASIC az aktuális sor végrehajtását kezdi meg. Ez utóbbi a leggyakoribb választott érték, mivel meglehetősen egyszerű megoldás egy utasítás számára az aktuális sor megváltoztatása (azaz a START változó módosítása úgy, hogy egy másik sorra mutasson. Ennek egy példája a GOTO, amely a START-ot úgy állítja be, hogy a sorszám által kijelölt sorra mutasson).
Nincs olyan utasítás, amely az STMTEND-nek a fent leírtaktól különböző értéket adhatna.

CURCHAN (209 hexa, 521 decimális)
Ez a byte az aktuális I/O csatornát tartalmazza. Általában ez 0, de pl. a PRINT £c-vel megváltoztatható.

CURPROG (20A hexa, 522 decimális)
Ez a byte az aktuális lapozott és végrehajtás / szerkesztés alatt álló program számát tartalmazza. Ezt semmilyen bővítő nem változtathatja meg.

PTR (214 hexa, 532 decimális)
Ez a pointer az éppen végrehajtódó sorban a következő elemre mutat. A GETITEM rendszerhívás irányítja.

START (216 hexa, 534 decimális)
Ez a pointer az éppen végrehajtódó sor elejére mutat.

LH (218 hexa, 536 decimális)
Ez a 16 bites változó egy egész / sor számot tartalmaz a GETITEM rendszerrutin meghívása után és még néhány más esetben. Ha 0 értéket vesz fel, ez azt jelzi, hogy érvénytelen sor / egész szám lett beolvasva.

TEXT (21A hexa, 538 decimális)
Ez a pointer a RAM-beli aktuális program elejére mutat. A 0. program esetében ez a 0. lapon lesz, más programoknál pedig az 1. lap elején.

CURLOC (21C hexa, 540 decimális)
Ez a pointer a soron következő szabad byte-ra mutat a CODE által még nem használt ALLOCATE által lefoglalt területen, azaz ez az aktuális hely számláló vagy program számláló.

EXTOP (21E hexa, 542 decimális)
Ez a pointer a legfölső BASIC bővítő utáni első byte-ra mutat, azaz az első byte-jára egy esetleges ALLOCATE által lefoglalt területnek.

MCTOP (220 hexa, 544 decimális)
Ez a pointer az első byte-ra mutat a felhasználó részéről ALLOCATE-tel lefoglalt terület után. Ez a 0. program kezdete lesz, ha az létezik. Ha a 0. program az aktuális, akkor a TEXT az MCTOP értékét kapja.

STKTOP (226 hexa, 550 decimális)
Ez a pointer a BASIC tárjának aljára mutat, amely elmozdulhat. Ez nem azonos a Z80 veremtárával.

STKPTR (228 hexa, 552 decimális)
Ez a BASIC tárban használt utolsó byte-ra mutat és lefelé terjeszkedik a memóriában. Az STKPTR értékét nem szabad elmenteni a BASIC meghívása alatt, mivel a tár elmozdulhat.

KEYPTRS (232 hexa, 562 decimális)
Ez a pointer a kulcsszó-leírókra mutató pointerek láncában az első táblára mutat. A pointert nem ajánlatos máshová irányítani.

VARPTR (234 hexa, 564 decimális)
Ez a pointer a szimbólumtábla soron következő szabad byte-jára mutat. Ez legalább 256 byte-tal az STKPTR alatt kell, hogy legyen.

VARBASE (236 hexa, 566 decimális)
Ez a pointer a szimbólumtábla egy bemenetére mutat, a magasabb című bemenetek lokálisak a legbelülről hívott felhasználó által definiált függvények számára.

OUCHPOS (242 hexa, 578 decimális)
Ha a fentebb definiált CURCHAH értéke 255, a rendszer meghívja az OUTCHAR-t és minden olyan hívásnál, ahol ez előfordul, a csatorna helyett a memóriába íródnak a karakterek. Az OUCHPOS pointer a beírt utolsó karakter utáni byte-ra mutat.

BUFF1 (248 hexa, 584 decimális)
Ebben a 255 byte-nyi bufferben tárolódnak a bemenő (input) sorok a tokenizáció és a parancs módban történő végrehajtás alatt. A csak végrehajtható utasítások számára ez egy általános munkaterület lehet.

SYMB (347 hexa, 839 decimális)
Ez a pointer a fent említett BUFF1 egy pozíciójára mutat tokenizálás alatt és a BASIC akkor használja, amikor pl. egy kulcsszó tokenizáló egy számot sorszámmá alakít át.

BUFF2 (349 hexa, 841 decimális)
Ez a 253 byte-os terület általában munkaterületként használható.

MSGBUFF (446 hexa, 1094 decimális)
Ezt a 80 byte-os buffert az MSG rendszerhívás használja a megadott kódnak megfelelő hibaüzenetek tárolására.

VALUE (595 hexa, 1429 decimális)
Ebben a 9 byte-os bufferben a GETITEM és READNUMBER rendszerhívások által lerakott lebegőpontos számok tárolódnak.

CHR (59E hexa, 1438 decimális)
Ebben a 20 byte-os bufferben egy szám ASCII reprezentációja áll a CFTOS által elvégzett átalakítás után.

HASHTAB (DCB hexa, 3531 decimális)
Ez annak a 32 belépéses hash táblának az eleje, amely a szimbólumtábla belépéseinek láncolatára mutató pointerekből áll.

X (E0B hexa, 3595 decimális)
Ez egy 7 byte nagyságú buffer. A transzcendentális függvények kiszámításakor, valamint az XASSIGN rendszerhíváskor használatos.

Y (E12 hexa, 3602 decimális)
Mint fent.

SEGTAB (E54 hexa, 3668 decimális)
Ez jelöli a változók végét és a BASIC szegmenskiosztási táblájának kezdetét, amelynek a mérete a rendszerben működő RAM szegmensek számától függ. Ahhoz mindig elég nagy, hogy a rendszer összes szegmensét tartalmazza.

6. Rendszerhívások
A BASIC rendszerhívások a System Call restart (RST 10H) utasításon keresztül hívhatók.
Az RST utasítást beépített függvényszámok követik (akárcsak az EXOS hívásoknál) vagy pedig olyan byte-sorozat, amely különböző végrehajtandó BASIC hívások sorozatát határozza meg. Ez a byte-sorozat a 0 függvényszámmal végződik, amelynek hatására a program rátér a soron következő utasításra.
A sorozatban minden byte egy rutint jelöl ki, de vannak olyan rutinok, amelyeknél közvetlenül a függvényszám után egy további adat-byte szükséges.
Ebben a könyvben a különböző rendszerhívásokra kényelmi okokból fantázianevükkel hivatkozunk. Ezeket a neveket fogjuk felsorolni az aktuális függvényszámokkal és az általuk használt Z80 regiszterekkel együtt. Ha külön nem módosítjuk, általában a másodlagos regiszterek tartalma (AF`,BC`,DE` és HL`) megőrződik. A 'tár' szó alatt a BASIC tárat értjük és nem a Z80-as veremtárat.

END (0)
Lezárja a rendszerhívások sorozatát, hogy folytatódhassék a program végrehajtása.
Bemenő adatok: -
Eredmény: megmarad az előzőleg végrehajtott rendszerhívás eredménye
Megőrződik: mindegyik regiszter

LOADINT (2 )
A HL-ben lévő előjeles egészet a BASIC tárba teszi.
Bemenő adatok: HL - a tárba küldendő szám.
Eredmény: IY - az STKPTR új értéke.

CFTOS (3)
A tár tetején lévő számot ASCII karakterlánccá alakítja anélkül, hogy a tárból törölné. A szám ASCII reprezentációját, melynek élén a hosszbyte áll és nem tartalmazza a szám előtt vagy után lévő szóközöket, negatív szám esetén pedig a `-` jellel kezdődik, a CHR bufferben rakja le.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.

FSGN (5)
A tár tetején lévő szám előjelét vizsgálja anélkül, hogy törölné onnan.
Bemenő adatok: A tárban.
Eredmény: A - 80H, ha a szám negatív, máskülönben 0, Z - a zéró flag értéke 1, ha a szám pozitív, IY - az STKPTR aktuális értéke.
Megőrződik: A, BC, DE, HL

FNEG (6)
A tár tetején lévő számot negálja.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.
Megőrződik: BC

?FNEG (7)
A tár tetején lévő számot negálja, ha az negatív volt, azaz veszi az abszolút értékét.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.
Megőrződik: BC

FCPL (8)
Veszi a tár tetején lévő szám 10-es komplemensét.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.
Megőrződik: BC

?FCPL (9)
Veszi a tár tetején lévő szám 10-es komplemensét, ha az negatív.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.
Megőrződik: BC

INT? (A hexa, 10 decimális)
A tár tetején lévő számot vizsgálja, hogy egész formátumú-e. A számot nem törli a tárból.
Bemenő adatok: A tárban.
Eredmény: A - a legfölső szám kitevőbe, Z - 1 értékű, ha a szám egész. IY - az STKPTR aktuális értéke.
Megőrződik: HL, DE, BC

FIX (B hexa, 11 decimális)
A tár tetején lévő számot egésszé alakítja és a HL-be teszi, utána kiveszi a számot a tárból. Hibát jelez, ha az átalakítandó szám túl nagy.
Bemenő adatok: IY - a tárban lévő számra mutat.
Eredmény: HL - az átalakított szám.
Megőrződik: BC, DE

FADD (C hexa, 12 decimális)
A tár két fölső elemét összeadja és helyettük az eredményt teszi a tárba.
Bemenő adatok: kivéve a tárból.
Eredmény: A tárban.
Megőrződik: AF

FSUB (D hexa, 13 decimális)
A tár legfölső elemét kivonja a tár következő eleméből és helyettük az eredményt teszi a tárba.
Bemenő adatok: kivéve a tárból.
Eredmény: A tárban.
Megőrződik: AF

FMULT (E hexa, 14 decimális)
A tár két fölső elemét összeszorozza és helyettesíti őket az eredménnyel.
Bemenő adatok: Kivéve a tárból.
Eredmény: A tárban.
Megőrződik: AF

FDIV (F hexa, 15 decimális)
A tár tetején következő elemmel elosztja a tár következő elemét és helyettesíti őket az eredménnyel.
Bemenő adatok: kivéve a tárból
Eredmény: A tárban
Megőrződik: AF

FCOMP (10 hexa, 16 decimális)
A tár két fölső elemét összehasonlítja és törli őket.
Bemenő adatok: kivéve a tárból.
Eredmény: P, M, Z flagek értéke úgy állítódik, mintha a legfölső számot kivonta volna az őt követő számból. H - a fenti flagekkel konzisztens számot tartalmaz.

FDIV10 (11 hexa, 17 decimális)
A legfölső szám mantisszáját 10-zel osztja jobbra történő decimális léptetéssel. A szám nem állhat egész formátumban.
Bemenő adatok: A - a léptetések száma.
Eredmény: IY - az STKPTR aktuális értéke.

ZERO? (12 hexa, 18 decimális)
A tár legfölső elemének BCD számjegyeit vizsgálja és ha mindegyik zéró, akkor a szám zéró reprezentációját (az egész 0-át) adja.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke. Z flag értéke 1, ha a szám a 0.
MegőrződiK: HL

FLOAT (13 hexa, 19 decimális)
A tár legfölső elemét vizsgálja, s ha az egész formátumú, akkor átalakítja BCD alakra.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.
Megőrződik: HL, BC

LOADNUM (14 hexa, 20 decimális)
A HL által kijelölt 6 byte-os lebegőpontos számot átmásolja a tárba, miközben átalakítja a 8 byte-os tár formába.
Bemenő adatok: HL - a 6 byte-os számra mutat.
Eredmény: HL - az STKPTR új értéke.

DUP (15 hexa, 21 decimalis)
A tárban lévő legfölső számot vagy stringet még egy példányban a tárba teszi.
Bemenő adatok: A tárban.
Eredmény: DE - az STKPTR új értéke.

POP (16 hexa, 22 decimális)
Kitörli a tárból a legfölső számot vagy stringet.
Bemenő adatok: A tárban.
Eredmény: HL - az STKPTR új értéke.

SETZERO (17 hexa, 23 decimális)
A tár legfölső elemét 0-ra állítja és biztosítja a tár típusbyte-jának megfeleld értékét. Ily módon ha az STKPTR-ből levonunk 8-at majd meghívjuk a SETZERO-t, ugyanazt a hatást érjük el, mintha 0-át PUSH-olnánk a tárba.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.
Megőrződik: HL, DE, BC

FSTEZERO (18 hexa, 24 decimális)
Ugyanaz, mint a SETZERO, csak ez a hatványkitevő byte-nak a 3FH értéket adja.

SETONE (19 hexa, 25 decimális)
Ugyanaz, mint a SETZERO, csak ez 1-et tesz a tárba.

FSETONE (1A hexa, 26 decimális)
Ugyanaz, mint az FSETZERO, csak ez 1-et tesz a tárba.

NUMASSIGN (1B hexa, 27 decimális)
A tárban lévő legfölső számot a HL által kijelölt 6 byte-os változóba másolja, miközben a 8 byte-os tár formátumból átalakítja a 6 byte-os szimbólumtábla formátumba. A szám nem törlődik a tárból.
Bemenő adatok: A tárban. HL - a változóra mutat.

STRASSIGN (1C hexa, 28 decimális)
A tárban lévő legfölső karakterláncot a HL által kijelölt változóba másolja anélkül, hogy törölné a tárból. Hibát jelez, ha a tárban lévő karakterlánc hosszabb, mint a változó maximális hossza.
Bemenő adatok: HL - a változó elejére mutat. Ez a karakterlánc maximális hosszát tartalmazó byte kell, hogy legyen.

PUTDIG (1D hexa, 29 decimális)
Értéket ad a tárban lévő legfölső szám egy kijelölt decimális számjegyének. A legnagyobb helyiértékű számjegy a 4-es számmal, a legkisebb helyiértékű számjegy a 13-as számmal van jelölve. Lásd részletesebben a 2.6 fejezetben (Számok).
Bemenő adatok: B - a számjegy száma. A - a beírandó érték (0 és 9 között)
Kimenet: IY - az STKPTR aktuális értéke.
Megőrződik: HL, DE, BC

GETDIG (1E hexa, 30 decimális)
A tárban lévő legfölső szám egy kijelölt decimális számjegyének értékét kiolvassa (lásd a fenti PUTDIG-et).
Bemenő adatok: B - az olvasandó számjegy száma.
Kimenet: IY - az STKPTR aktuális értéke. A - az olvasandó érték (0 és 9 között). Z flag az A-nak megfelelően beállítva.
Megőrződik: HL, DE, BC

NORMALISE (1F hexa, 31 decimális)
A tárban lévő legfölső számot addig lépteti jobbra vagy balra, amíg a legnagyobb helyiértékű számjegy normál pozícióba nem jut (azaz a 4-es pozícióba). A számot balra lépteti, ha a túlcsordult számjegyek nem 0-ák (elvesztve a kiléptetett számjegyeket), vagy jobbra, ha a 4-es számjegy 0 és a szám nem egyenlő 0-val.
Bemenő adatok: A tárban.
Eredmény: IY - az STKPTR aktuális értéke.

GETITEM (20 hexa, 32 decimális)
A forráskódból beolvassa a következő elemet. A PTR és a START változók definiálják a forráskódon belül az aktuális pozíciót, s a GETITEM megnöveli a PTR-t úgy, hogy a következő elemre mutasson, de a sor végén túl már nem olvas semmit.
Bemenő adatok: A PTR által kijelölt aktuális elem.
Eredmény: Az átállított PTR. A - a SIGNIS új értéke. Z flag értéke 1 sorvége esetén.
Megőrződik: HL, DE, BC, IY

A SYMBTYPE, SYMBLEN és SIGNIS változók a beolvasott elemnek megfelelően állítódnak be. Ezen változók értéke kapcsolatban áll a forráskód tokenizálásának módjával (lásd részletesen a 2.2 fejezetet (Program)). A különböző elemtípusokra a változóértékek a következőképpen állítódnak be.

Továbbá, a SYMB változó a forráskódban lévő elem leíróbyte-ja mögött álló adatra mutat. Ez az azonosító, szám, karakterlánc, stb. kezdete. Az LN változó 0, azt az esetet kivéve, amikor a beolvasott elem egész szám vagy sorszám. Ekkor a beolvasott elem értékét veszi fel. Ha a beolvasott elem szám, akkor az átmásolódik a VALUE bufferba.

GETSIGN (22 hexa, 34 decimális)
Ha az A-ban és a SIGNIS-ben lévő írásjel kódok nem egyeznek meg, hibajelzést ad. Máskülönben meghívódik a GETITEM.
Bemenő adatok: A - az összehasonlítandó írásjel
Eredmény: Ua., mint a fenti GETITEM-nél
Megőrződik: HL, DE, BC, IY

EXPRESSION (23 hexa, 35 decimális)
Numerikus kifejezést értékel ki, s az eredményt leteszi a tárba. Megjegyezzük, hogy ennek a rutinnak a hívása más utasítás vagy függvény hívását is előidézheti (egy felhasználó által definiált függvényen keresztül), beleértve magát a meghívó rutint is, ha a hívó rutin utasítás- vagy függvénybővítő. Ezért minden bővítőnek újraindíthatónak kell lennie.
Eredmény: A tárban.

STREXPR (24 hexa, 36 decimális)
Hasonló a fenti EXPRESSION-hoz, csak ez karakterlánc (string) kifejezést értékel ki. A rekurzivitásra ugyanazok a meggondolások érvényesek.
Eredmény: Eredmény-karakterlánc a tárban.

GETCHAR (25 hexa, 37 decimális)
Az alapbillentyűzet csatornáról beolvasott karaktert adja vissza, vagy 0-át, ha nincs beolvasandó karakter.
Eredmény: A - a karakter vagy 0. A flagek az A-nak megfelelően vannak beállítva.
Megőrződik: HL, IY

CHKNUM (27 hexa, 39 decimális)
Elegendő helyet biztosit a tárba teendő szám részére a BASIC tárban, szükség esetén a tárat is áthelyezve. Ha már nincs több hely a tárban és nincs hozzáférhető memória sem, hibát jelez.

CHKSTR (28 hexa, 40 decimális)
Mint a fenti CHKHUM, csak karakterláncok számára biztosít helyet a tárban.
Bemenő adatok: DE - a tárba küldendő karakterlánc hossza.

MINSTK (29 hexa, 41 decimális)
A tárat a lehető legmélyebbre helyezi a memóriában, hogy az EXOS számára a lehető legtöbb helyet szabadítsa föl. Csatornanyitás előtt használatos.

DEBLANK (2A hexa, 42 decimál i s )
A PTR változót az első nem üres karakterre irányítja (átugorva a tabokat és szóközöket).
Bemenő adatok: PTR
Eredmény: Átállított PTR.
Megőrződik: DE, BC, IY

READNUMBER (2B hexa, 43 decimális)
A PTR változó által kijelölt szövegből beolvassa egy lebegőpontos szám ASCII reprezentációját és átalakítja egy 8 byte-os BASIC-tár reprezentációba a VALUE bufferbe. A PTR-t közben átállítja. Ha a szám 1 és 9999 közti egész volt, ezt az LN változóba is beteszi, amely máskülönben 0 értékű.
Bemenő adatok: PTR
Eredmény: Átállított PTR.
Megőrződik: HL - a 0 és 9999 közti egész szám

RND (2D hexa, 45 decimális)
Egy 24 bites véletlen számot ad vissza.
Eredmény: A HL - a véletlen szám.
Megőrződik: DE, IY

FINDLN (2E hexa, 46 decimális)
Megkeresi a kijelölt sort a programban.
Bemenő adatok: HL - a keresendő sorszám.
Eredmény: HL - a megtalált sor elejére mutat, ha nem találja, akkor a soron következő legnagyobb sorszámú elejére. BC - a HL-től számított relatív érték a következő sor elejére. A carry értéke 1, ha nem találja a sort.
Megőrződik: IY

LISTLN (2F hexa, 47 decimális)
A HL által kijelölt sort kinyomtatja arra a csatornára, amelyet a CURCHAN változóban lévő szám meghatároz. A bekezdéseket megtartja. Ha a CURCHAN értéke 255, akkor a sort a memória OUCHPOS által kijelölt részére teszi, az OUCHPOS-t pedig átállítja az utolsó karakter + 1 helyre.
Bemenő adatok: HL - a kinyomtatandó sor elejére mutat.
Eredmény: HL - a következő sor elejére mutat.

DLTLN (30 hexa, 48 decimális)
Törli a HL által kijelölt sort, valamint kiüríti a tárat és a szimbólumtáblát. Csak parancs módú utasításoknál használható.
Bemenő adatok: HL - a törlendő sor elejére mutat.
Eredmény: HL - a következő sor elejére mutat (vagyis nem változik).

CLRPR (31 hexa, 49 decimális)
Olyan inicializálást hajt végre, amely RUN vagy más hasonló parancsnál szükséges. Törli az 1-100 csatornákat, a szimbólumtáblát, ellenőrzi a bekezdés-byte szinteket, kiüríti a BASIC tárat, inicializálja a futási értékeket.

BLCKCH (32 hexa, 50 decimális)
Végigvizsgálja az egész programot. Amennyiben DEF vagy HANDLER blokkokat talál, felveszi azokat a szimbólumtáblába.

BLCKCN (33 hexa, 51 decimális)
Megkeresi a programban az aktuálisan vizsgált sorral megegyező bekezdés-byte-ú következő sort. Egy blokk kezdő utasítás végrehajtásánál használatos annak ellenőrzésére, hogy van-e megfelelő blokk vége utasítás.
Eredmény: HL-ben a megtalált sor kezdőcíme található.

STOPPR (34 hexa, 52 decimális)
Ha ez a függvény programból hívódott, akkor kiírja a CURCHAH által meghatározott csatornára a "STOP at line " + aktuális sorszám üzenetet és megszakítja a program futását. Parancs üzemmódban csak a "STOP" üzenetet írja ki.

KEYMODE (35 hexa, 53 decimális)
A kijelölt kulcsszó kulcsszó-táblájából megadja a flag-byte-ot.
Bemenő adatok: C - a kulcsszó száma.
Eredmény: B - a flag-byte. HL - a flag-byte-ra mutat.
Megőrződik: IY

READLINE (36 hexa, 54 decimális)
Egy input sort beolvas (ASCII carriage return-nel lezárva, 0DH) a BUFF bufferbe a CURCHAN-nal kijelölt csatornáról. A beolvasott karakterek száma a buffer első byte-jában lesz.
Eredmény: A carry értéke 1, ha a file végére értünk. HL - a buffer első karakterére mutat.
Megőrződik: IY

OUTCHAR (38 hexa, 56 decimális)
Az A-ban lévő karaktert a CURCHAH által kijelölt csatornára küldi vagy ha a CURCHAN , értéke 255, akkor a karaktert az OUCHPOS által kijelölt memóriaterületre írja, s az OUCHPOS értékét eggyel növeli.
Bemenő adatok: A - a kiküldendő karakter.
Megőrződik: AF, BC, DE, HL, IY.

PRTNO2 (39 hexa, 57 decimális)
A HL-ben lévő egészet kiküldi a fenti OUTCHAR segítségével.
Bemenő adatok: HL - a kiküldendő szám (nem előjeles), C - a vezető nulla pozíciókra nyomtatandó ASCII karakter. C=O esetén ezeket elhagyja. Ha a carry értéke 1, 4 számjegyet nyomtat ki, máskülönben 5 számjegyet.

INDEX (3B hexa, 59 decimális)
A szimbólumtábla egy változójára mutató pointert adja, s ha ez a változó vektorváltozó, akkor a pointert a program aktuális pozíciójában álló indexszel meghatározott vektorelemre igazítja.
Bemenő adatok: HL - a változóhoz tartozó adatterületre mutat a szimbólumtáblában. C - a változó szimbólumtáblabeli típusbyte-ja. B - a 0. bit értéke 1 normál műveletnél. Ha 0-ra van állítva, az INDEX csak kielemzi a következő index kifejezést. Lásd az _EXPRESSION és az _STREXPR hívásokat.
Eredmény: HL - a változó adatterületére mutat, azaz nem módosul, ha a változó nem vektor, illetve a kijelölt elemre mutat, ha vektor.

CHANNO (3C hexa, 60 decimális)
Ellenőrzi azt, hogy a program következő eleme csatornaszám-e ('£'-al jelölve). Hibajelzést ad ha nem. Utána kiszámolja és visszaadja a csatornaszámot.
Eredmény: A - a csatornaszám
Megőrződik BC, DE

CPREST (3D hexa, 61 decimális)
Egy kulcsszó tokenizáló rutinjának hívása után hívandó. Biztosítja az utasítás hátralévő részének pontos tokenizálását. Ha egy utasításbővítő nem kívánja meg a tokenizáló rutin használatát (általában ez a helyzet), akkor helyette ezt a rutint kell hívni.

OUTSTR (3E hexa, 62 decimális)
Egy stringet küld ki karakterenként a már említett OUTCHAR segítségével. A stringben lévő karakterek száma az első byte-ban tárolódik.
Bemenő adatok: HL - a string elejére mutat.
Megőrződik: BC, DE, IY

UPRINT (3F hexa, 63 decimális)
A BASIC tárban lévő legfölső számot kiírja ASCII-ben a már említett OUTCHAR segítségével anélkül, hogy törölné a tárból. A számot az előjelétől függően egy szóköz karakter vagy egy '-'jel előzi meg és egy szóköz karakter követi.
Bemenő adatok: A tárban.

_STREXPR (40 hexa, 64 decimális)
Kielemez egy string kifejezést anélkül, hogy visszaadna valamilyen eredményt vagy meghívna bármilyen, a kifejezésben eléforduló felhasználó által definiált függvényt. Általában a kulcsszó-tokenizáló rutinokban használatos.

_EXPRESSION (41 hexa, 65 decimális)
Kielemez egy numerikus kifejezést anélkül, hogy visszaadna valamilyen eredményt vagy meghívna bármilyen, a kifejezésben előforduló felhasználó által definiált függvényt. Általában a kulcsszó-tokenizáló rutinokban használatos.

LINKSYM (80 hexa, 128 decimális )
A HL által kijelölt szimbólumtáblát beláncolja a szimbólumtáblázatba. Olyan függvénybővítők beláncolásánál használatos, amelyeknek a belépése (de nem szükségképpen a kódja) a 0. lapon van. Lásd a 4. fejezetben (Bővítő Függvények) részletesen a belépések formátumát.
Bemenő adatok: HL - a csatolandó tábla 0. lapon lévő belépésére mutat.
Megőrződik: IY

ADDNAME (81 hexa, 129 decimális)
Hozzáadja egy azonosító flag-byte-ját és nevét a szimbólumtáblához. Az aktuális programelem (amit a fent leirt GETITEM szolgáltat) azonosító kell, hogy legyen.
Bemenő adatok: A - a belépés típusbyte-ja.
Megőrződik: IY

ADDNUM (82 hexa, 130 decimális)
Egy szimbólumtábla-formátumban lévő számot ad a szimbólumtáblához és 'inicializálatlan' jelzéssel látja el. Például, ha a fent leírt ADDNAME után az ADDNUM kerül meghívásra, akkor egy hiánytalan egyszerű numerikus változó fog hozzáadódni a szimbólumtáblához. Lásd a 2.3 fejezetet (Szimbólumtábla).
Megőrződik: IY, HL

ADDSTR (83 hexa, 131 decimális)
Hasonló a fent leirt ADDNUM-hoz, de ez egy string adatmezőt csatol a szimbólumtáblához és 'inicializálatlan' jelzéssel látja el.
Bemenő adatok: C - a string maximális hossza.
Megőrződik: HL, IY

ADDENT (88 hexa, 136 decimális)
Egy teljes belépést biztosit egy egyszerű numerikus vagy string azonosítónak az azonosító típusától függően, ahol az azonosító a GETITEM által biztosított aktuális elem (lásd fentebb). A string maximális hossza az alaphossz (132 karakter).
Eredmény: HL - az új belépés elejére mutat.
Megőrződik: IY

ADDFN (89 hexa, 137 decimális)
Egy felhasználó által definiált függvény bemenetét adja a szimbólumtáblához. Az aktuális sor kezdőcímét (mely a START-ban található) a string vagy numerikus adat után teszi le. Lásd a 2.3 fejezetben (Szimbólumtábla) részletesebben a belépések formátumát. A függvény neve a GETITEM által biztosított aktuális programelem.

ADDREF (8A hexa, 138 decimális)
Egy olyan belépést ad a szimbólumtáblához, amely egy másik belépéshez referencia. A függvények referencia paramétereinek átadásakor használatos.
Bemenő adatok: HL - annak a belépésnek az adatterületére mutat, amelyre hivatkozunk. A - a hozzáadott belépés típusa.
Megőrződik: IY

FINDSYM (8B hesa, 139 decimális)
Egy olyan azonosítót keres a szimbólumtáblában, amely megegyezik a forrásprogramban aktuális elemként szereplő azonosítóval (melyet a GETITEM szolgáltat). Ha nem talál ilyet, egy új belépést készít és 'inicializálatlan' jelzéssel látja el. Kifejezések kiértékelésekor használatos.
Eredmény: HL - a belépés adatterületére mutat. C - a belépés típusbyte-ja.
Megőrződik: IY

DEFSYM (8C hexa, 140 decimális)
Hasonló a fenti FINDSYM-hez, ellenben ha a megtalált belépés egy gépi kódú függvény (azaz egy beépített függvény vagy egy függvénybővítő), akkor egy új belépést készít. A LET és a hozzá hasonló utasításokban használatos, amelyekben beépített függvények újradefiniálása lehetséges.
Eredmény: HL - a belépés adatterületére mutat. C - a belépés típusbyte-ja. Megőrződik: IY

SYM? (8E hexa, 142 decimális)
Hasonló a fenti DEFSYM-hez, de ez nem készít új belépéseket, csak átvizsgálja az aktuális, felhasználó által definiált függvényhívásnak megfelelő szimbólumtáblát, azaz azon szimbólumok halmazát, amelyeket az aktuális függvényhívás szolgáltat. Abban az esetben, ha nem aktív egy felhasználó által definiált függvény sem, ez a teljes szimbólumtáblát jelenti.
Eredmény: A carry értéke 1, ha nem találja a nevet.
Megőrződik: IY

CLRSYM (8F hexa, 143 decimális)
Törli az összes nem gépi kódú függvényt a szimbólumtáblából, azaz a beépített függvények és a függvénybővítők kivételével mindent.
Megőrződik: IY

LOAD (91 hexa, 145 decimális)
A HL által kijelölt 7 byte-os formátumban lévő számot a tárba teszi, a tárban használatos számformátumban.
Bemenő adatok: HL - a szám első byte-jóra mutat.
Eredmény: HL - az STKPTR új értéke.
Megőrződik: IY

CLOAD (92 hexa, 146 decimális)
Egy 12 számjegyű (7 byte-os) formátumban lévő konstanst tesz a tárba az ott használatos számformátumban.
Eredmény: A tárban lévő konstans.
Megőrződik: IY
A konstanst a CLOAD-hoz tartozó RST kód után lévő konstans sorszám jelenti. A konstansok a ROM-ban vannak. A meghatározott konstans számhoz tartozó aktuális konstans értékek a következők:

NLOAD (93 hexa, 147 decimális)
Hasonló a fenti LOAD-hoz, de a 0. lapon lévő szám címe az NLOAD-hoz tartozó RST kódot (93H) normál Z80 formátumban követi.
Eredmény: A szám a tárban
Megőrződik IY

XLOAD (94 hexa, 148 decimális)
A lebegőpontos X regiszterben lévő számot a tárba teszi.
Eredmény: X a tárban.
Megőrződik: IY

YLOAD (95 hexa, 149 decimális)
Hasonló az XLOAD-hoz, csak az Y regiszterben lévő számot teszi a tárba.
Eredmény: Y a tárban.
Megőrződik: IY

NASSIGN (96 hexa, 150 decimális)
A tár legfölső elemét a 0. lapon lévő bufferbe másolja. A bufferre a NASSIGN-hoz tartozó RST kód (96H) után lévő cím mutat. A szám a tár formátumból alakul a már említett ideiglenes 7 byte-os formátumba, továbbá törlődik a tárból.
Bemenő adatok: A tárból veszi ki.
Megőrződik: IY

XASSIGN (97 hexa, 151 decimális)
Kiveszi a tárból a legfölső elemet és átmásolja az X lebegőpontos regiszterbe.
Bemenő adatok: A tárból veszi ki.
Megőrződik: IY

P_NUM (99 hexa, 153 decimális)
Elemez a következő szintaktikának megfelelően: ' ( <kifejezés> ) '. Az eredményt ,leteszi a tárba.
Eredmény: A <kifejezés> eredménye a tárban.

P1_NUM (9A hexa, 154 decimális )
Elemez a kővetkező szintaktikának megfelelően: ' ( <kifejezés> '. Az eredményt leteszi a t árba.
Eredmény: A <kifejezés> eredménye a tárban.

P2_NUM (9B hexa, 155 decimális)
Elemez a következő szintaktikának megfelelően: ' ,<kifejezés> '. Az eredményt leteszi a t árba.
Eredmény: A <kifejezés> eredménye a tárban.

P_STR (9C hexa, 156 decimális)
Elemez a következő szintaktikának megfelelően: ' ( <string-kifejezés> ) '. A string-kifejezés eredményét leteszi a tárba.
Eredmény: A <string-kifejezés> eredménye a tárban.

P1_STR (9D hexa, 157 decimális)
Elemez a következő szintaktikának megfelelően: ' ( <string-kifejezés> '. A string-kifejezés eredményét leteszi a tárba.
Eredmény: A <string-kifejezés> eredménye a tárban.

P2_STR (9E hexa, 158 decimális)
Elemez a következő szintaktikának megfelelően: , ' <string-kifejezés> '. A string-kifejezés eredményét leteszi a tárba.
Eredmény: A <string-kifejezés> eredménye a tárban.

P_ARRAY (9F hexa, 159 decimális)
Elemez a következő szintaktikának megfelelően: ' ( <vektor-azonosító>
Eredmény: HL - a belépés adatterületére mutat. C - a belépés típusbyte-ja.

P_END (A0 hexa, 160 decimális)
Elemez a következő szintaktikának megfelelően: ' ) '. Azaz ellenőrzi, hogy van-e jobb zárójel.

FRE (A1 hexa, 161 decimális)
Az aktuális programban rendelkezésre álló byte-ok számát adja meg.
Eredmény: A byte-ok száma a tárban.

ATN (A2 hexa, 162 decimális)
A tár tetején lévő szám arcus-tangensét számolja ki radiánokban. Az X és Y lebegőpontos regisztereket elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

ASIN (A3 hexa, 163 decimális)
A tár tetején lévő szám arcus-sinusát számolja ki radiánokban. Az X és Y lebegőpontos regisztereket elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

SIN (A4 hexa, 164 decimális)
A tár tetején lévő szám sinusát számolja ki radiánokban. Az X lebegőpontos regisztert elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

COS (A5 hexa, 165 decimális)
A tár tetején lévő szám cosinusát számolja ki radiánokban. Az X lebegőpontos regisztert elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

TAN (A6 hexa, 166 decimális)
A tár tetején lévő szám tangensét számolja ki radiánokban. Az X és Y lebegőpontos regisztereket elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

EXP (A7 hexa, 167 decimális)
Az e szám hatványát számolja ki, ahol a kitevő a tár tetején lévő szám. Az X és Y lebegőpontos regisztereket elrontja.
Bemenő adatok: A tarból veszi ki.
Eredmény: A tárban.

RAD_DEG (A8 hexa, 168 decimális)
A tár tetején lévő számot radiánból fokokba alakítja át OPTION ANGLE DEGREES állapotban. Általában trigonometrikus függvények értékeinek kiszámítása után használatos, s így biztosítja, hogy az eredmény megfelelő egységben legyen.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

DEG_RAD (A9 hexa, 169 decimális)
A tár tetején lévő számot fokokból radiánokba alakítja át OPTION ANGLE DEGREES állapotban. Általában trigonometrikus függvények értékeinek kiszámítása előtt használatos, s így biztosítja, hogy az argumentum radiánokban legyen.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

LOG10 (AA hexa, 170 decimális)
Kiszámítja a tár tetején lévő szám 10-es alapú logaritmusát. Az X lebegőpontos regisztert elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

MOD (AB hexa, 171 decimális)
Kiszámítja " a modulo b"-t , ahol b a legfölső, a pedig a következő elem a tárban. Az X és Y lebegőpontos regisztereket nem befolyásolja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

SQR (AC hexa, 172 decimális)
Kiszámítja a tár tetején lévő szám négyzetgyökét. Az X és Y lebegőpontos regisztereket elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

RECIP (AD hexa, 173 decimális)
Kiszámítja a tár tetején lévő szám reciprokát. Az Y lebegőpontos regisztert elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

INT (AE hexa, 174 decimális)
Kiszámítja a tár tetején lévő szám egész részét. Ez a számnál nem nagyobb legnagyobb egész szám. Az X és Y lebegőpontos regisztereket nem befolyásolja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

ROUND (AF hexa, 175 decimális)
Az IY-nal kijelölt számot az előírt decimális helyiértékre kerekíti.
Bemenő adatok: IY - a számra mutat (rendszerint az STKPTR aktuális értéke. A - az előírt helyiérték száma
Eredmény: IY - az eredményre mutat (azaz nem romlik el).
Megőrződik: IY, AF

INVOL (B0 hexa, 176 decimális)
Veszi az a szám b-edik hatványát, ahol b a legfölső, a pedig az őt követő elem a tárban. Elrontja az X és Y lebegőpontos regisztereket.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

IP (B1 hexa, 177 decimális)
Kiszámítja a tár legfölső elemének egész részét. Megjegyezzük, hogy negatív számokra nem egyezik meg az INT-tel. Az X lebegőpontos regisztert elrontja.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

SGN (B2 hexa, 178 decimális)
A -1, 0 vagy 1 értéket adja vissza attól függően, hogy a tárban lévő legfölső szám negatív, nulla vagy pozitív. Az X és Y lebegőpontos regiszterekre nincs hatással.
Bemenő adatok: A tárból veszi ki.
Eredmény: A tárban.

DELIST (BA hexa, 186 decimális)
Programsorok sorszámokkal adott tartományát kitörli vagy kilistázza. Ha törlés történik, akkor a szimbólumtábla és a tár is kiürül.
Bemenő adatok: HL - az első törlendő sorszám. DE - az utolsó törlendő sorszám. A másodlagos carry (az AF'-ben) 1 listázás esetén.

ERRM (BF hexa, 191 decimális)
A HL-ben lévő hibaszámnak megfelelő hibaüzenetet az MSGBUFF nevű bufferbe rakja. A buffer első byte-ja a hibaüzenet hosszbyte-ja lesz. Ha nincs rendelkezésre álló előírt hibaüzenet, a BASIC egy általánosabb üzenetet ad vissza, leírva a típusát. A 9000 és a 9255 közti hibaszámokat az EXOS dolgozza fel.
Bemenő adatok: HL - hibaszám.
Eredmény: A carry értéke 1, ha rendelkezésre áll előírt hibaüzenet. Megőrződik: IY

SL (C1 hexa, 193 decimális)
Végigvizsgálja az egész programot miközben ellenőrzi a sorok bekezdés-byte-jait. Például a LIST előtt használatos, biztosítja a megfelelő bekezdéseket a listázás során.
Megőrződik: IY

CASE (C4 hexa, 196 decimális)
A tár tetején lévő stringet nagy- vagy kisbetűssé alakítja.
Bemenő adatok: B - 60H nagybetű, 40H kisbetű esetén.
Eredmény: A tárban.
Megőrződik: IY

FKEY (C5 hexa, 197 decimális)
Újraprogramozza a billentyűzet funkcióbillentyűit a BASIC-beli alapértelmezésre.
Megőrződik: IY

Vissza