1. A BASIC programozási nyelv

1.1 Általános ismertetés

A BASIC nyelv, angol nyelvû rövidítésének megfelelõen (Beginners All-purpose Symbolic Instruction Code) a kezdõ felhasználók ideális eszköze a számítógéppel történõ kom- munikációban. Nemcsak egy programozási nyelvet jelent, hanem az operációs rendszert is helyettesíti mûködése alatt, így népszerûségét tovább növelte, hogy a BASIC-re alapozott (többnyire személyi-) számítógépek szabványos kapcsolatot (interface-t) tartanak a külvilággal. Ez korábban egyáltalán nem volt megszokott jelenség, mert legtöbbször minden új számítógép-konstrukció más vezérlõ nyelvvel (Job Control Language) került piacra, ezért a gép kezelését újra kellett tanulni.

A BASIC alapvetõen három feladatot lát el, s ennek megfe- lelõen három üzemmódja van: parancs, szerkesztõ és prog- ramfuttató üzemmódokat különböztethetünk meg. A felhasználó számára a fenti tény nem nyilvánvaló, mert a billentyûzetet egyformán kell kezelni, talán csak a programfuttató üzemmód az, amelyik a többitõl egyértelmûen elhatárolható (külön utasítással /RUN, esetleg GOTO ill. GOSUB/indítandó, s a program befejezéséig/megszakításáig/tart).

Egyébként az elsõ BASIC-ekben csak a begépelt sor értelmezésekor (interpretálásakor) derül ki, hogy a gépnek most parancsot kell-e végrehajtania, vagy a BASIC programot akarjuk szerkeszteni (ha a sor 'egész szám' alakban kezdõdik /ahol _=szóköz/blank/, akkor azt szerkesztendõ programsornak tekinti, egyébként pedig megkísérli a sort parancsként végrehajtani). Érdemes megjegyezni: az egyes üzemmódokban használható utasítások köre változó, pl.: parancs üzemmódban nem írhatunk definíció jellegû utasítást (DATA, DIM, DEF...), és a BASIC program már nem tartalmazhat programszerkesztési (AUTO, DELETE, NEW, RENUM), illetve operációs-rendszer vezérlõ utasításokat (LIST, LLIST, LOAD MERGE, SAVE). A Turbo- ill. a QuickBasic-ben, nem is beszélve a Windows alatt mûködõ VisualBasic-rõl, a szerkesztõ és futtató utasítások menübõl érhetõk el. A beírt programsor nem szükségképpen kezdõdik sorszámmal és nem hajtódik végre azonnal. A különféle szerkesztési szabályokat az egyes fejezetek elején írjuk le.

Változók és tömbök

A többi fejlettebb programozási nyelvhez hasonlóan a BASIC is felmenti a felhasználót a memóriakezelés közvetlen irányításától, ami azt jelenti, hogy ha adatot kívánunk tárolni a számítógép memóriájában, akkor nem szükséges annak tárolási helyét közvetlenül kijelölnünk, hanem elegendõ az adathoz egy nevet hozzárendelnünk egy változónév=adat alakú értékadó utasítás formájában, és az adatra ezután már a változónévvel hivatkozhatunk. Nem kulcsszó nevek elsõ érzékelésekor (szabály: csak betûvel kezdõdhetnek!) a BASIC ezekhez hozzárendeli a szabad memória - ami kezdetben általában 64 Kb hosszú - következõ, a változó típusának megfelelõ hosszú szakaszát, és az így megjelölt területet elzárja más felhasználás elõl. A változó típusát nevének utolsó karaktere írhatja elõ (%: egész típus, !:egyszeres pontosságú valós, #:dupla pontosságú valós, $:karakter- sorozat /string/ típus), de típus hozzárendelés a név elsõ karakteréhez is köthetõ a DEFINT, DEFSNG, DEFDBL, DEFSTR típusdefiniáló utasításokkal. A fentiek hiányában alapértelmezésként a változókhoz az egyszeres pontosságú lebegõpontos típus rendelõdik.

A továbbiakban az egyes változótípusok jellemzõit ismer- tetjük:

egész típusú:

hossza 2 byte, s rajta az [-32768,32767] intervallumba esõ egész számok kettes komplemens kódban vannak tárolva.

egyszeres pontosságú valós:

hossza 4 byte, s rajta a számok lebegõpontos bináris formában vannak tárolva (1 byte exponens, 3 byte mantissza), kb. 7 értékes tizedes jeggyel.

dupla pontosságú valós:

hossza 8 byte, s rajta a számok lebegõpontos bináris formában vannak tárolva (1 byte exponens, 7 byte mantissza), kb. 15 értékes tizedes jeggyel,

string típusú:

a változóhoz rendelt stringet (jelsorozatot) csonkítás nélkül, legfeljebb 255 byte-on tárolja ASCII kódban. A változóra történõ ismételt értékadás új terület lefoglalását eredményezi, ezért használatuk elõ- vigyázatosságot igényel, mert gyorsan a szabad memória kimerülését okozhatják.

Logikai adatot bármely számtípusú változóhoz rendelhetünk!

Esetenként az egyszerû változók használata már nem elégít ki minket (pl. adatsor feldolgozásakor), hanem indokoltnak látszik tömbök bevezetése. A BASIC ilyenek deklarálását (helyfoglalását), használatát is támogatja. Tömbök segítségével közös néven hivatkozhatunk azonos típusú változók egy csoportjára. A tömb egy-egy adatát tömbön belüli helyzete (indexe/i/) alapján azonosíthatjuk. A BASIC általában nem korlátozza a tömb indexeinek számát (pl. az egyindexes tömbök vektorok, a kétindexesek mátrixok tárolására szolgálnak), de a tömbök összméretét is korlátozza a rendelkezésre álló szabad memória nagysága. Természetesen ugyanolyan típusú tömböket definiálhatunk a DIM utasítással, mint amilyen típusú változókat egyébként is használhatunk. Ugyanazon név alatt szerepeltethetünk a programban egyszeres és tömbváltozót is, mert az adatra történõ hivatkozás úgyis egyértelmûvé teszi, melyiket kell használni.

Példák változókra:

Az A%, B%, CICA% egész típusú változók. Az A%(2), B%(K,J), CICA% (4,K,S) olyan tömbök elemei, amelynek valamennyi eleme egész típusú. Egy programon belül alkalmazható A% és A%(...) is, illetve CICA% és CICA%(...) is. A zárójel miatt különbözõ neveknek kell tekinteni.

Az A, A!, CICA, CICA!, A(2), A!(2), CICA(K,L), CICA!(K,L) egyszeres pontosságú valós változók. A ! nem kötelezõ, így A és A!, CICA és CICA!, valamint A(2) és A!(2) ugyanazt a memóriarekeszt jelentik. A tömböknek valamennyi eleme egyszeres pontosságú valós.

Az A#, CICA#, A#(3), CICA#(K,L) dupla pontosságú valós változók.

Az A$, CICA$, A$(5), CICA$(K,L) string változók.

Az A$(...) és CICA$(...) tömbök valamennyi eleme string minden elem hossza 1 és 255 byte között lehet. Egy programban használható A%, A, A#, A$ változó, különbözõ memóriarekeszt jelentenek, egymáshoz semmi közük nincs, nem jelenti egyik a másik átalakított értékét.

A BASIC igyekszik elnézõ lenni a felhasználóhoz, programozási hibáit egy bizonyos határig tolerálja, ezért pl.: a tömbök deklaráció nélkül is használhatók. A tömbnév elsõ elõfordulásakor az indexek számának megfelelõ dimenziójú tömb helyfoglalása automatikusan megtörténik, azzal a korlátozással, hogy az egyes indexek értéke a 10-et nem haladhatja meg (és az indexek számozása 0-nál kezdõdik).

Adatkonstansok

Példák egész típusú konstansokra: 5,-32000,16000,&Hb800 (hexad.)

Példák egyszeres pontosságú lebegõpontos konstansokra: 5.,-32000!,16000.57,16E+3

Példák dupla pontosságú lebegõpontos konstansokra: 5.D+0,-32000#,16000.57D+0,16D+3

Példák string-konstansokra: "ablak","Ajto","%12 Ab lak", "12345".

Példák logikai konstansokra: -1 (igaz), 0 (hamis) (A gép a matematikai logikai igaz 1 helyett a -1-et használja).

Aritmetikai mûveletek és függvények

- : elõjelváltás, kivonás

+ : összeadás,

* : szorzás

/ : osztás

\ : egész típusú osztás

^ : hatványozás

A mûveletek közötti prioritási szabály a matematikában szokásos. Egyenrangú mûveletek esetében balról jobbra haladva történik a mûveletek elvégzése. A mûveletek sorrendjének ettõl eltérõ kijelölése a ( ) zárójelek használatával lehetséges.

ABS : abszolútérték képzés

ASC : karakter ASCII kódja

ATN : arcus tangens függvény

COS : cosinus függvény

EXP : exponenciális függvény

INT : egészrész-képzés

LEN : string hossza

LOG : e alapu logaritmus

SGN : elõjel függvény

SIN : sinus függvény

SQR : négyzetgyök függvény

TAN : tangens függvény

VAL : stringbe írt számkonstans értéke

Aritmetikai kifejezésen olyan képletet értünk, amely számértékû konstansokat, változókat, függvényeket tartalmaz, aritmetikai mûveletekkel összekapcsolva. Aritmetikai kifejezés értéke numerikus szám. Az aritmetikai függvények argumentumát, azt a kifejezést, változót, vagy konstanst, amelynek függvényértékét kell kiszámítani ( ) zárójelbe kell tenni.

Példák aritmetikai kifejezésekre:

A + B

(A^2 + B^3)/2

(A*B + B*C)\4

EXP(A*57D+3)

SIN((4*ATN(1))/2)

Valamennyi konstans és változó önmagában is kifejezés.

Logikai mûveletek és függvények

AND : logikai és

EQV : ekvivalencia

IMP : implikáció

NOT : negáció

OR : logikai vagy

XOR : kizáró vagy

Egyszerû logikai kifejezés két aritmetikai vagy két string kifejezés relációval való összekapcsolása. Értéke logikai érték: igaz (-1) vagy hamis (0). Példák: A<=B A<>B A=B (A^2+B^3)/2 = SIN((4*ATN(1))/2) "ABC"+A$ <= LEFT$(B$,6)

Összetett logikai kifejezés egyszerû logikai kifejezések, logikai értékû változók összekapcsolása logikai mûveletekkel, vagy függvényekkel. Logikai kifejezés értéke logikai érték: igaz vagy hamis.

Példák:

A<=B AND C<>D ugyanezt jelenti a következõ:

(A<B OR A=B) AND (NOT C=D)

Ebbõl következik, hogy

(A<=B AND C<>D) EQV ((A<B OR A=B) AND (NOT C=D)) kifejezés igaz.

String-mûveletek és függvények

+ : egyesítés, egymás után írás

CHR$ : karakter-generátor

HEX$ : hexadecimális alakú számkonstans string generálása

LEFT$ : bal rész-string kiemelése

MID$ : középsõ rész-string kiemelése

OCT$ : oktális alakú számkonstans string generálása

RIGHT$ : jobb rész-string kiemelése

SPACE$ : szóköz-string képzése

STR$ : számkonstans string generálása

STRING$: szabályos karaktersorozat képzése

String (vagy karakter) kifejezésen olyan képletet értünk, amely string konstansokat, változókat, függvényeket tartalmaz, esetleg az egyetlen + egyesítés (konkatenálás) string mûvelettel összekapcsolva. String kifejezés értéke string. String függvények argumentumát ( ) zárójelbe kell tenni.

Példák string kifejezésre:

A$

A$ + SPACE$(4)

LEFT$(A$,1)

RIGHT$(A$ + SPACE$(4), 5)

MID$(RIGHT$(B$,4), 2, 3)

STR$(245)

Kifejezések használata:

Sem aritmetikai sem logikai sem string kifejezések önálló programutasításként nem állhatnak. Valamennyit egyéb utasítások használhatják paraméterként.

Értékadás

Kifejezés alatt tulajdonképpen olyan képletet értünk, ami már korábban ismertetett formájú konstansokat, mûveleteket és függvényeket, korábban definiált változókat és szabályos zárójelezést tartalmazhat. Alapvetõ szabály, hogy a változó és a kifejezés típusa megegyezzen, ezen belül a számtípusok egymást helyettesíthetik, de pl. stringet nem rendelhetünk számhoz. A zárójelezés teszi lehetõvé a mûveletek elvégzése prioritásos sorrendjének felülbírálását, de a kezdõ és végzárójelek száma meg kell hogy egyezzen.

Adatbeolvasás

Adat beolvasható magából a program listájából (DATA és READ), billentyûzetrõl (INPUT, LINE INPUT), adatfile-ból (INPUT#, LINE INPUT#, GET#).

Adatkiírás

Adat kiírható a képernyõre (PRINT, WRITE), a nyomtatóra (LPRINT), adatfile-ba (PRINT#, WRITE#, PUT#).

Ciklus-szervezés

Ciklusról beszélünk akkor, ha egy programrészletet többször egymás után akarunk végrehajtatni. Ha az ismétlések száma elõre ismert, akkor a ciklusba tartozó utasításokat (a ciklus magját) a FOR ..., NEXT utasításpárral fogjuk közre. Ha a ciklus ismétlése valamely logikai feltételtõl függ, akkor használjuk a WHILE ..., WEND utasításpárt.

Szubrutin-szervezés

Ha a program különbözõ pontjain ugyanazt az utasítássoro- zatot kell végrehajtanunk (csak esetleg más értékekkel, paraméterekkel), akkor szervezzünk szubrutint, azaz az ismétlõdõ utasítássorozatot különítsük el a fõprogramtól (tegyük pl. a program végére), és zárjuk le egy RETURN utasítással. A fõprogram megfelelõ pontjain az így kiemelt utasítássorozat végrehajtását a GOSUB szubrutinhívó utasítással kezdeményezhetjük.

Feltételes és feltétel nélküli vezérlés-átadás

A program általában olyan sorrendben hajtódik végre, ahogy a listán az utasítások sorban követik egymást. Ezt a végrehajtási sorrendet módosítják a ciklusok, a szubrutinok, de a vezérlés a program bármely más pontjára is átadható a GOTO utasítással (mindenesetre ciklus és szubrutin magjába 'kívülrõl' beugrani nem ajánlatos).

Logikai feltételtõl függõ vezérlés-átadást az IF...THEN... ELSE... utasítás-konstrukcióval kivitelezhetünk. Kijelölt címkéjû sorok között az ON utasítással választhatunk.

File kezelés

A számítógéphez kapcsolt háttértárolón (lemezegységen) programokat és adatfile-okat tarthatunk a 'felejtés' ve- szélye nélkül (a memória a számítógép kikapcsolása után elveszti tartalmát!). A BASIC-ben megírt programokat a SAVE utasítással menthetjük, és a LOAD vagy MERGE utasítással tölthetjük vissza. A háttértárolón található file-ok katalógusa a FILES parancssal kérdezhetõ le, tetszõleges file-t a KILL utasítással törölhetünk, és hossza a LOF függvénnyel kérdezhetõ le.

Az adatfile-ok rekordszervezésûek. Egy rekord a logikai (és bizonyos mértékig fizikai) értelemben összetartozó adatok halmaza. Ha a rekordok hossza nem rögzített, akkor a file csak szekvenciálisan (a rekordok csak felírásuk sorrendjében érhetõk el) kezelhetõ, ellenkezõ esetben lehetséges a file- on belüli közvetlen rekordra pozícionálás.

Az adatfile kijelölését, típusát, használatának módját az OPEN utasítással írhatjuk elõ, és a munka befejeztével a CLOSE utasítással zárhatjuk le. A program normál befejezõdése esetén külön utasítás nélkül is megtörténik a nyitott file-ok lezárása, de különösen írásra megnyitott file-ok esetén célszerû a lezárásról külön is gondoskodni, nehogy adatvesztés következzen be! Olvasáskor a file-vége figyelését az EOF logikai függvény biztosítja. Egyidejüleg csak korlátozott számú file lehet nyitva!

A számítógép egyes perifériái file-ként is elérhetõk, ha az alábbi egyezményes neveket használjuk (a kettõspont része a filenévnek!):

SCRN: csak outputra megnyitható eszköz, a képernyõ.

KYBD: csak inputra megnyitható eszköz, a billentyû- zet.

LPT[n]: az [n]-dik párhuzamos port, pl.: nyomtató.

COM[n]: az [n]-dik soros port, pl.: egér.

NUL: az üres eszköz, az erre írt adatok elvesznek.

Véletlenszám generálás

A BASIC-nek nagyon hasznos sajátossága, hogy beépített (pseudo-) véletlenszám generáló függvényt is tartalmaz (RND), ami a [0,1] intervallumon egyenletes eloszlású vé- letlenszámot ad vissza. A valószínûség-számításból ismert, hogy egy ilyen véletlenszám generátorral bármely más eloszlású véletlen számsorozat is elõállítható! A generált számsorozat megismételhetõ, mert a RANDOMIZE utasítás lehetõvé teszi, hogy más alkalommal is ugyanattól a ponttól indítsuk újra a sorozatot.

Hibafigyelés futás közben

ON ERROR GOTO sorszám; alakú utasítás a futás közbeni hibák lekezelésére alkalmas. Rendszerváltozóként ERR a hiba kódját, az ERL függvény pedig elõfordulásának helyét szolgáltatja. Ezt a feltételfigyelést bekapcsolni nem kell, de a hibadetektáló rutint a RETURN helyett a RESUME utasítással kell lezárni.

A BASIC kulcsszavak ABC szerinti leírása

Az alábbi leírásban szögletes zárójelbe [] írjuk a nem kötelezõen választható opciókat. A [] jelek nem tartoznak hozzá az utasításhoz a programsorba nem szabad beleírni. A mintapéldákban a programsorok sorszámmal kezdõdnek, mert az eredeti BASIC-ekben ez még kötelezõ volt.

ABS (függvény):

abszolútérték-képzés, pl. y=ABS(x), ahol x számkifejezés.

10 X=125:Y=-442.7                                       
20 PRINT ABS(X),ABS(Y)                                  
RUN                                                     
 125           442.7

ASC (függvény):

ASCII-kód képzés, pl. y=ASC(x$), ahol x$ stringkifejezés, y pedig x$ elsõ karakterének kódja.

10 yx$="AbcD123"                                         
20 PRINT asc(yx$)                                        
RUN                                                      
 65 

ATN (függvény):

arcus tangens függvény, pl. y=ATN(x), ahol x számkifejezés, y pedig a radiánban mért szög.

10 pi=4*atn(1)                                           
20 x=16                                                  
30 PRINT pi,4*atn(x/16)                                  
RUN                                                      
 3.141593      3.141593 

AUTO (utasítás):

automatikus sorszámozás beállítása, pl. AUTO [x],[y] ahol x jelöli a program elsõ sorának sorszá- mát, y pedig a sorszámozás növekményét. x=10, y=10/default, azaz alapértelmezés szerinti értékek x vagy y elhagyása esetén ezekkel az értékekkel mûködik az utasítás.

CDBL (függvény):

dupla pontos számba konvertál, pl. x#=CDBL(y).

10 y=125.0123456789                                       
20 x#=cdbl(y)                                             
30 PRINT y,x#                                             
RUN                                                       
 125.0124      125.0123443603516                          

CHAIN (utasítás):

új programot tölt be, esetleg változó- érték átadással, illetve programtörléssel, pl. CHAIN [MERGE] x$[,y[,ALL][,DELETE z,q]], ahol x$ a file-név, y az indítási sor száma, z-q a törlendõ sorok halmaza. Ha ALL szerepel, akkor minden változó megõrzi értékét, egyébként csak a COMMON utasításban felsoroltak.

10 Y=890.76:A$="789abs"                                   
20 X#=CDBL(Y)                                             
30 PRINT Y,X#,A$                                          
40 CHAIN "a:konvert.bas",10,ALL                           
RUN                                                       
 890.76        890.760009765625           789abs          
 125.0124      19999.08984375             789abs   tzuuio 
LIST                                                      
10 Y=125.0123456789#                                      
20 E$="tzuuio"                                            
25 X#=19999.09                                            
30 PRINT Y,X#,A$,E$                                       

CHDIR (utasítás):

megváltoztatja az aktuális könyvtárat (mint a 'change directory' parancs), pl. CHDIR x$, ahol x$ az új út.

CHR$ (függvény):

karaktert gyárt ASCII kódból, pl. y$=CHR$(x) jelenti azt a karaktert, melynek ASCII táblabeli kódja x.

10 X=65                                                  
20 PRINT CHR$(X)                                         
RUN                                                      
A                                                        

CINT (függvény):

egész számra konvertál, pl. y=CINT(x).

10 X=3456.123:Y=-345.123:Z=123.78:W=-123.78              
20 PRINT CINT(X),CINT(Y),CINT(Z),CINT(W)                 
RUN                                                      
 3456         -345           124          -124           

CLEAR (utasítás):

törli a változókat, és helyet foglal a programnak és a veremnek, pl. CLEAR [x[,y]], ahol x az adatszegmens hossza (max. 65535), y pedig a stacknek igényelt hossz.

10 A$="asdfghkjkl"                                       
20 PRINT "A string 10 karakter.",FRE(A$),A$              
30 CLEAR                                                 
40 PRINT"A string ures.",FRE(A$),A$                      
50 A#=12345.567879#                                      
60 PRINT "8 byte-os valtozoval:",FRE(A#),A#              
70 CLEAR                                                 
80 PRINT "Nelkule:             ", FRE(A#),A#             
Ok                                                       
RUN                                                      
A string 10 karakter.        59908        asdfghkjkl     
A string ures.               59915                       
8 byte-os valtozoval:        59903         12345.567879  
Nelkule:                     59915         0             

CLOSE (utasítás):

lezárja a megnyitott eszközöket, file- okat. Alakja CLOSE [#sorsz]. Ha a sorszám elmarad, minden nyitott csatornát lezár (akárcsak a programfutás vége).

CLS (utasítás):

törli a képernyõt (akárcsak a SCREEN uta- sítás).

COLOR (utasítás):

beállítja a használható színeket, pl. COLOR x,y,z, ahol x az elõtér színe, y a háttéré, z pedig a kereté. A választható színek száma függ a használt üzemmódtól.

COMMON (utasítás):

a változók értékének átadását teszi lehetõvé egy láncolt (CHAIN) programhoz. Ha minden változót át akarunk adni, használjuk az ALL opciót! Példa: COMMON változó[,változó]. Lehetõleg a program elején használjuk!

10 COMMON A$,Y                                           
20 C=243:B$="asdf" :A$="qwert"                           
30 PRINT "elso program"                                  
40 PRINT "C="C,"B="B$,"Y="Y,"X#="X#,"A$="A$              
60 CHAIN "a:lancolt.bas",10                              
70 PRINT  A,B,C$,B$,Y,X#                                 
RUN                                                      
elso program                                             
C= 243        B=asdf        Y= 0          X#= 0         
A$=qwert 
Lancolt program                                          
Y= 125.0124   X#= 19999.08984375          A$=qwert      
E$=tzuuio 
C= 0                                                     
LIST                                                     
10 Y=125.0123456789#                                     
20 E$="tzuuio"                                           
30 X#=19999.09                                           
40 PRINT "Lancolt program"                               
50 PRINT "Y="Y,"X#="X#,"A$="A$,"E$="E$,"C="C             
Ok                                                       
RUN                                                      
Lancolt program                                          
Y= 125.0124   X#= 19999.08984375          A$=           
E$=tzuuio 
C= 0                                                     

CONT (utasítás):

utasítással (STOP vagy END) illetve billentyûvel (Ctrl-Break) megszakított program folytatását teszi lehetõvé. Közben más, közvetlen utasítások is végrehajthatók, de a programot javítani nem szabad.

10 PRINT "Elso sor"                                     
20 PRINT "Masodik sor"                                  
30 PRINT "Stop.Gepeld be -CONT-!"                       
40 STOP                                                 
50 PRINT "Otodik sor"                                   
Ok                                                      
RUN                                                     
Elso sor                                                
Masodik sor                                             
Stop.Gepeld be -CONT-!                                  
Break in 40                                             
Ok                                                      
cont                                                    
Otodik sor                                              

COS (függvény):

koszinusz-függvény számítás, pl. y=COS(x), ahol x radiánban értendõ!

10 PI=4*ATN(1)                                          
20 PRINT COS(PI/3)                                      
RUN                                                     
 .4999999                                               

CSNG (függvény):

egyszerû pontos valós számmá redukál, pl. y=CSNG(x#).

10 X#=1234.567890123457#                                
20 Y=CSNG(X#)                                           
30 PRINT X#,Y                                           
RUN                                                     
 1234.567890123457           1234.568                   

CVI (függvény):

stringet konvertál egész számmá, pl. y%=CVI(x$). Az adat belsõ ábrázolása nem változik, csak szám típusú lesz. Az MKI$ függvény inverze! A példát lásd a GET és CVD utasításnál. CVS (függvény): stringet konvertál valós számmá, pl. y!=CVS(x$). Az adat belsõ ábrázolása nem változik, csak szám típusú lesz. Az MKS$ függvény inverze! A példát lásd a GET és CVD utasításnál. CVD (függvény): stringet konvertál duplapontos számmá, pl. y#=CVD(x$). Az adat belsõ ábrázolása nem változik, csak szám típusú lesz. Az MKD$ függvény inverze!

10 X$="123456789012345"                                 
20 Y%=CVI(X$):Z=CVS(X$):W#=CVD(X$)                      
30 PRINT X$,Y%                                          
40 PRINT Z,W#                                           
Ok                                                      
RUN                                                     
123456789012345              12849                      
 9.264219E-24                1.515492070353-22          

Lásd még a GET utasítást!

DATA (utasítás):

konstansok programbeli tárolását teszi lehetõvé. Ld. még a READ utasítást!

DATE$ (függvény):

visszaadja az aktuális dátumot mm-dd-yyyy formában (hó-nap-év), de utasításként is használható, akkor mi aktualizálhatjuk a dátumot, pl. DATE$="01-01-1990".

DEF FN (utasítás):

függvénydefiníciós utasítás, pl. DEF FN2(x)=x*x. A függvény használatára példa: PRINT FN2(z).

10 DEF FNKOCKA(A)=6*A*A                                
20 X=3.28:Y=442                                        
30 PRINT X;"oldalu kocka felszine";FNKOCKA(X)           
40 PRINT Y;"oldalu kocka felszine";FNKOCKA(Y)           
RUN                                                    
 3.28 oldalu kocka felszine 64.5504                    
  442 oldalu kocka felszine 1172184                     

DEFDBL (utasítás):

az itt felsorolt kezdõbetûkkel jelölhetõk ki, hogy a használt változók duplapontos típusúak legyenek, pl. DEFDBL O-T.

DEFINT (utasítás):

az itt felsorolt kezdõbetûkkel jelölhetõk ki, hogy a használt változók egész típusúak legyenek, pl. DEFINT I-N.

DEFSNG (utasítás):

az itt felsorolt kezdõbetûkkel jelölhetõk ki, hogy a használt változók egyszerû valós típusúak legyenek, pl. DEFSNG A-H.

DEFSTR (utasítás):

az itt felsorolt kezdõbetûkkel jelölhetõk ki, hogy a használt változók string típusúak legyenek, pl. DEFSTR U,V,X-Z

DELETE (utasítás):

törli a program egy részét, pl. DELETE 250: egy sor törlése DELETE -250: a program elejének törlése DELETE 250-: a program végének törlése DELETE 250-700: a program közepének törlése

DIM (utasítás):

helyet foglal a tömbnek, pl. DIM A(1000), B(100,100) azaz helyfoglalás vektornak és mátrixnak.

EDIT (utasítás):

lehívja a program megfelelõ sorát javítás végett, pl. EDIT 150. Az aktuális sorszám ponttal helyettesíthetõ.

ELSE (utasítás):

ld. az IF utasításnál.

END (utasítás):

befejezi a program futtatását, lezárja a nyitott file-okat és áttér parancs üzemmódba.

EOF (függvény):

megadja, hogy a lekérdezett file elérte-e már a végét (logikai), pl. v=EOF(1).

10 OPEN "I",#1,"a:adat.dat"                              
20 FOR I=1 TO 100                                        
30 INPUT#1,Y                                             
40 PRINT EOF(1);Y ,                                      
50 IF EOF(1) THEN GOTO 70                                
60 NEXT I                                                
70 CLOSE  #1                                             
Ok                                                       
RUN                                                      
 0  1          0  0         0  1         0  3      0  0 
 0  3          0  6         0  0         0  6      0  10 
 0  0          0  10        0  15        0  7      0  15 
 0  21         0  0         0  21        0  28     0  0 
 0  28         0  36        0  0         0  3      0  45 
 0  0          0  45        0  55        0  0     -1  55 
Ok 

ERASE (utasítás):

törli az elõírt tömböket, pl. ERASE A,B. Törlés nélkül a tömbök nem definiálhatók újra.

10 DIM A(10,10)                                         
20 FOR I=1 TO  10                                       
30 FOR J=1 TO 10                                        
40 A(I,J)=123                                           
50 NEXT J,I                                             
60 PRINT "Szabad byte-ok a tombbel",FRE(A)              
65 DIM A(5,5)                                           
70 ERASE A                                              
80 PRINT "ERASE utan:",FRE(A)                           
90 REM Lehet ujradimenzionalni.                         
100 DIM A(5,5)                                          
RUN                                                     
Szabad byte-ok a tombbel     59406                      
Duplicate Definition in 65                              
delete 65                                               
RUN                                                     
Szabad byte-ok a tombbel     59419                      
ERASE utan:    59914                                    

ERL (függvény):

hiba esetén a hibát okozó sor számát adja vissza.

ERR (függvény):

hiba esetén a hiba kódját adja vissza.

ERROR (utasítás):

segítségével tetszõleges kódú hibát ge- nerálhatunk a programban (tesztcélokra), pl. ERROR 36.

10 ON ERROR GOTO 100                                    
20 INPUT "Hanyadik honap?",N                            
30 IF N<1 OR N>12 THEN ERROR 210                        
40 END                                                  
100 IF ERR=210 THEN PRINT "A honapok szama rossz!":GOTO 900 
Ok                                                      
RUN                                                     
Hanyadik honap?13                                       
A honapok szama rossz!                                  

EXP (függvény):

e alapú hatványozást végez.

10 A=1:B=COS(4*ATN(1)/2)                                
20 PRINT EXP(1),EXP(A),EXP(B)                           
RUN                                                     
 2.718282      2.718282      .9999998                   

FIELD (utasítás):

véletlen file bufferéhez változókat rendel, pl. FIELD#1, 2 AS A$,3 AS B$, ahol a file 1 sorszámmal lett megnyitva, és 5 hosszú rekordjához az A$ és B$ stringeket rendeltük.

FILES (utasítás):

megfelel a 'directory list' rendszerpa- rancsnak, tehát listázza a katalógust, pl. FILES "*.BAS"

FIX (függvény) :

egészrészre csonkít, pl. y=FIX(x), csak negatív x-re különbözik az INT függvénytõl.

10 X=125.2:Y=125.7:X2=-125.2:Y2=-125.7                 
20 PRINT FIX(X),FIX(Y),FIX(X2),FIX(Y2)                 
RUN                                                    
 125           125          -125          -125         

FOR (utasítás):

ciklusszervezõ utasítás, pl. FOR x=y TO z STEP q ahol x értékei a következõk lesznek: y, y+q, y+2.q, ...,y+n.q. A cikluskezdõ FOR utasítástól a cikluszáró NEXT z utasításig levõ utasítás-sorozatot a gép a fent felsorolt összes x értékre végrehajtja mindaddig, míg x aktuális értéke nem haladja meg z-t. Ha x = y + k*q > z valamely k egész szám esetén a program végrehajtása a cikluszáró NEXT utasítást követõ programsorral folytatódik. A ciklusok többszörösen egymásba ágyazhatók, de akkor a cikluszáró utasításoknak fordított sorrendben kell szerepelniük. Egy NEXT utasítással több ciklus is lezárható, pl. NEXT i,j,k formában. Ha a STEP opciót elhagyjuk, akkor a lépésköz q=1.

10 FOR I=1 TO 4  STEP .4                                
20 PRINT I;                                             
30 J=J+1                                                
40 NEXT I                                               
50 PRINT                                                
60 PRINT "A ciklusvaltozo erteke a ciklus elhagyasakor";I 
RUN                                                     
 1  1.4  1.8  2.2  2.6  3  3.4  3.800001                
A ciklusvaltozo erteke a ciklus elhagyasakor 4.200001   

FRE (függvény):

visszadja a BASIC által még szabadon felhasználható szabad terület nagyságát. Pl. PRINT FRE(X). Ha az argument string típusú, akkor az eredmény közlése elõtt a BASIC adattömörítést végez, hogy a közben felszabadult stringterületeket is elérhesse.

GET (utasítás):

beolvas egy rekordot egy véletlen elérésû file-ról. Pl. GET#1,n ; azaz beolvassa az 1-re megnyitott file n-dik rekordját a FIELD utasítás kijelölte bufferbe.

10 OPEN "R",#1,"vletlen.fle",40                           
20 FIELD #1,10 AS NEV$,15 AS SZEMSZ$,5 AS IR$,5 AS BER$   
30 FOR I=4 TO 2 STEP -1                                   
100 GET #1,I                                              
110 PRINT NEV$,CVD(SZEMSZ$),CVI(IR$),CVS(BER$)            
120 NEXT I                                                
Ok                                                        
RUN                                                       
Nemeth         28509234567   9400          88.8         
Molnar         18201175678   8777          99.90       
Szabo          28305153456   8000         675.5           

GOSUB (utasítás):

szubrutinhívást tesz lehetõvé egy adott címkére, melynek végrehajtása után a RETURN utasítás hatására ugrik vissza a GOSUB utasítást követõ utasításra.

10 DIM A(5)                                           
20 FOR I=1 TO 5                                       
40 A(I)  =I                                           
50 NEXT I                                             
60 PRINT "1.szubrutinhivas";:GOSUB 200                
70 PRINT "      Vissza 1" :A(4)=100                   
80 PRINT "2. szubrutinhivas";:GOSUB 200               
110 PRINT "     Vissza 2" :A(2)=200                   
120 PRINT "3.szubrutinhivas";:GOSUB 200               
130 PRINT "     Vissza 3"                             
140 END                                               
200 FOR I=1 TO 5                                      
210 PRINT A(I);                                       
220 NEXT I                                            
240 RETURN                                            
RUN                                                   
1. szubrutinhivas 1  2  3  4    5      Vissza 1       
2. szubrutinhivas 1  2  3  100  5      Vissza 2       
3.szubrutinhivas 1  200  3  100  5     Vissza 3       

GOTO (utasítás):

feltétlen ugró utasítás, pl. GOTO 490.

HEX$ (függvény):

létrehoz egy stringet, mely az argumentum hexadecimális alakját tartalmazza, pl. y$=HEX$(x).

10 X=123.16 :Y$=HEX$(X)                               
20 PRINT Y$                                           
RUN                                                   
7B                                                    

IF (utasítás):

feltételes programelágazást tesz lehetõvé.

Alakja: IF kifejezés THEN utasítások [ELSE utasítások] ; vagy IF kifejezés GOTO címke [ELSE utasítások] ; ahol a 'kifejezés' egy logikai kifejezést, az 'utasítás' pedig egy BASIC parancssort jelent. Mûködése: ha a logikai kifejezés értéke igaz, akkor a végrehajtás a 'címke' soron folytatódik, ill. a THEN-t követõ utasítások kerülnek végrehajtásra, egyébként pedig az ELSE-t követõ utasításokat hajtja végre a gép.

10 IF x=x  THEN PRINT "Ezeket az utasitasokat hajtja vegre 
1."    :I=I+1:PRINT "Kovetkezo utasitasra lep." ELSE PRINT 
"Ezeket  
 nem.":Z=0                                             
20 IF  0   THEN PRINT "Ezeket nem hajtja vegre":X=ATN(1) 
           ELSE  PRINT "Ezeket hajtja vegre.":Y=123    
RUN                                                    
Ezeket az utasitasokat hajtja vegre 1.                 
Kovetkezo utasitasra lep.                              
Ezeket hajtja vegre.                                   

INKEY$(függvény):

a billentyûzeten megnyomott karaktert adja vissza. Ha nem történt billentyûmegnyomás, akkor eredményül az üres stringet adja.

10 PRINT "Nyomjon meg egy billentyut!"                 
20 A$=INKEY$:IF A$="" THEN GOTO 20                     
30 PRINT  A$                                           
Ok                                                     
RUN                                                    
Nyomjon meg egy billentyut!                            
g                                                      

INPUT (utasítás):

A billentyûzetrõl olvas be értékeket a felsorolt változókba. Alakja: INPUT ["szöveg";]változó-lista. Ha a "szöveg" opciót használjuk, akkor a képernyõn a szöveg megjelenik, és a beolvasás csak utána indul. A megnyomott billentyûknek megfelelõ karakterek a képernyõn is megjelennek! Ha egy utasítással több változóhoz olvasunk be értéket, akkor a begépelt értékeket vesszõvel válasszuk el. Amennyiben a begépelt adatok nincsenek összhangban (számban vagy típusban) a változólistával, akkor '?Redo from start' hibajelzéssel válaszol, mely után az adatbevitelt meg kell ismételni.

10 INPUT "Adj meg egy valos szamot es egy stringet!";A,B$ 
20 PRINT "A valtozok erteke:", A,B$                      
Ok                                                       
RUN                                                      
Adj meg egy valos szamot es egy stringet!? 34            
?Redo from start                                         
Adj meg egy valos szamot es egy stringet!? "string"      
?Redo from start                                         
Adj meg egy valos szamot es egy stringet!? "ez is",34    
?Redo from start                                         
Adj meg egy valos szamot es egy stringet!? 
12345.678,ezisstring 
A valtozok erteke:           12345.68     ezisstring    

INPUT# (utasítás):

adatokat olvas be megnyitott szekvenciális file-ról vagy eszközrõl. Alakja: INPUT#file-szám, változólista

10 OPEN "I",#1,"adat.dat"                              
20 INPUT #1,X,B$,Y                                     
30 PRINT"1. beolvasas:" X,B$,Y                         
40 INPUT #1,X,B$,Y                                     
50 PRINT"2. beolvasas:", X,B$,Y                        
RUN                                                    
1. beolvasas: 1             1              1  
2. beolvasas:  3            12             3  

INPUT$ (utasítás):

adott számú byte-ot olvas be egy megnyitott file-ról vagy eszközrõl. Alakja: y$=INPUT$(byteszám, file-szám)

10 OPEN "I",#1,"adat.dat"                              
20 Y$=INPUT$(7,#1)                                     
30 PRINT y$                                            
RUN                                                    
1,"1",1                                                

INSTR (függvény):

Alakja: v=INSTR([n,]x$,y$) Hatása: megkeresi y$ string elsõ elõfordulását x$-ban, annak n-dik karakterétõl kezdve, és v-be kerül azon pozíció sorszáma, ahol megtalálta, vagy 0, ha bármely okból a keresés nem volt sikeres.

10 A$="9876543abcd3456"                                
20 V=INSTR(A$,"3"):W=INSTR(8,A$,"3")                   
30 PRINT V,W                                           
RUN                                                    
 7             12                                      

INT (függvény):

egészrész függvényt számol, pl. y=INT(x).

10 x=12.4:y=12.7:x2=-12.4 :y2=-12.7                    
20 PRINT int(x), int(y), int(x2), int(y2)              
RUN                                                    
 12            12           -13           -13          

KILL (utasítás):

Megegyezik a 'delete file' rendszerpa- ranccsal, vagyis file-törlésre használható, és ugyanúgy lehet paraméterezni is, pl. KILL "*.OBJ"

LEFT$ (függvény):

Hívása:y$=LEFT$(x$,n). Funkciója: y$-ba teszi az x$ n hosszú baloldali rész-stringjét.

10 a$="123abc"                                        
20 PRINT LEFT$(A$,2),LEFT$(A$,4)                      
RUN                                                   
12            123a                                    

LEN (függvény):

meghatározza a string hosszát, pl. y=LEN(x$).

10 x$="123abc":y$="12v"                               
20 PRINT len(x$),len(y$)                              
RUN                                                   
 6             3                                      

LET (utasítás):

az értékadó utasítás [elhagyható] kulcs- szava. Hívása: LET y=kifejezés.

10 let x=123.4                                        
20 x2=123.4                                           
30 let y =4*atn(1)                                    
40 y2=4*atn(1)                                        
50 PRINT x,x2,y,y2                                    
RUN                                                   
 123.4         123.4         3.141593      3.141593 

LINE INPUT (utasítás):

egy egész (Enterrel lezárt) sort olvas a billentyûzetrõl egy stringváltozóba. A billen- tyûzött karakterek a képernyõn is megjelennek. Alakja: LINE INPUT ["üzenet";] x$.

10 rem Pelda INPUT-ra.                               
20 INPUT "Adjon egy karaktersort!",a$                
30 rem Pelda LINE INPUT-ra.                          
40 line input "Adjon egy karaktersort 2!",b$         
50 PRINT "1.sor",a$                                  
60 PRINT "2.sor",b$                                  
RUN                                                  
Adjon egy karaktersort! akarmi es vesszo,            
?Redo from start                                     
Adjon egy karaktersort! akarmi es                    
Adjon egy karaktersort 2! akarmi es vesszo,          
1.sor         akarmi es                              
2.sor         akarmi es vesszo,                      

LINE INPUT# (utasítás):

egy egész (Enterrel lezárt) sort olvas a file-ról egy stringváltozóba. Alakja: LINE INPUT#fileszám, x$.

10 DIM H$(10)                                        
20 OPEN "i" ,#1,"a:hput"                             
25 REM Beolvasunk egy programot,melyet hardcopy-val 
mentettunk el. 
30 FOR I=1 TO 10                                     
40 LINE INPUT# 1,H$(I)                               
50 NEXT I                                            
60 FOR I=1 TO 10                                     
70 PRINT H$(I)                                       
80 NEXT I                                            
RUN                                                  
LIST 10-800                                          
10 OPEN "r",#1,"veletlen.fle",40                     
20 FIELD #1,15 AS NEV$,20 AS CIM$,5 AS TEL$          
30 FOR I=3 TO 1 STEP -1                              
40 INPUT "NEV;CIM;TELEFON",N$,C$,T$                  
50 LSET NEV$=N$:LSET CIM$=C$:LSET TEL$=T$            
60 REM A FIELD mezökre nem történhet beolvasás.      
70 PUT #1,I                                          
80 REM Az i. rekordot töltjük fel .                  
90 NEXT I                                            

LIST (utasítás):

listázza a memóriában levõ program adott részletét. Alakja: LIST [line1] [-[line2]]. Pl. LIST 45; egy sort listáz LIST 45-; a program végét listázza LIST -45; a program elejét listázza LIST 45-350 ; a program közepét listázza LIST ; az egész programot listázza

LLIST (utasítás):

ugyanaz, mint LIST, csak a lista nem képernyõre, hanem nyomtatóra kerül.

LOAD (utasítás):

beolvas [és futtat] file-ról egy programot. Alakja: LOAD file-név [,R] ; pl. LOAD "A:\ENYEM\PROBA". Ha az 'R' opciót megadtuk, akkor a betöltés után a program azonnal futni kezd.

LOC (függvény):

visszaadja az aktuális, file-on belüli pozíciót. Hívása: v=LOC (fileszám).

LOCATE (utasítás):

a cursort pozícionálja az aktív képer- nyõn, de paraméterei segítségével szabályozhatja a cursor méretét, villogását is: LOCATE sor, oszlop, cursor, start, stop. Ha cursor=0, akkor nem látszik, és a cursor függõleges méretét a 0 < start, stop < 32 paraméterek állítják be.

LIST 
10 LOCATE 13,20                                         
20 PRINT "13.sor 20.oszlop"                             
30 LOCATE,,1                                            
40 INPUT K                                              
50 LOCATE 25,1                                          
60 PRINT "Utolso sor"                                   
70 LOCATE 20,,,1,7                                      
Ok                                                      
RUN                                                     
                                                        
                                                     
                   13.sor 20.oszlop                     
? 4                                                     
 
 
 
 
Ok 

LOF (függvény):

a megnyitott file hosszát adja vissza, pl. v=LOF(1). Ha a függvényt COM: perifériához használjuk, akkor értéke a szabad helyek száma az input buffer-ban.

10 OPEN "I",#1,"a:adat.dat"                            
20 PRINT "A file hossza!",lof(1)                       
30 CLOSE  #1                                           
RUN                                                    
A file hossza!               150                       

LOG (függvény):

természetes alapú logaritmust számol, pl. y=LOG(x).

10 PRINT exp(log(exp(1)))                              
RUN                                                    
 2.718282                                              

LPOS (függvény):

a nyomtatófej aktuális pozícióját adja az LPT1: printer bufferében.

10 FOR I=1 TO 10                                       
20 LPRINT "1234567890";LPOS(0);                        
30 IF LPOS(0)>45 THEN LPRINT                           
40 NEXT I                                              
50 REM Ha a sor hossza nagyobb,mint 45 ,uj sort kezd a 
nyomtato. 

LPRINT (utasítás):

ld. a PRINT utasításnál, az eltérés csak az, hogy a lista nem képernyõre, hanem a nyomtatóra kerül.

LPRINT USING (utasítás):

ld. a PRINT USING utasításnál, az eltérés csak az, hogy a lista nem képernyõre, hanem a nyomtatóra kerül.

LSET (utasítás):

adatot tölt stringváltozóba annak elmozdítása nélkül. Egyszerû értékadás (LET) esetén a stringváltozó minden értékadáskor új helyre kerül, ami megengedhetetlen un. FIELD változók esetében, mert a buffer helye futás közben nem változhat. Az LSET a stringet balra tömörítve teszi le, és a kimaradt jobboldali pozíciókba szóközt tölt. Pl. LSET y$=x$. Lásd még PUT utasítást!

MERGE (utasítás):

a memóriában levõ BASIC programot egy ASCII file-on tárolt másik programmal egészíti ki. A mûvelet csak akkor sikerülhet, ha a beolvasandó program-file-t az ',A' opcióval mentettük ki (ld. SAVE)!

10 OPEN "O",#1,"adat.dat"                               
20 FOR I=1 TO 10                                        
30 A=A+I:B$=B$+HEX$(I): C=C+I                           
40 WRITE#1,A,B$,C                                       
50 NEXT I                                               
60 CLOSE                                                
Ok                                                      
MERGE"a:amerglt"                                        
Ok                                                      
LIST 70-800                                             
200 OPEN "I",#1,"adat.dat"                              
210 INPUT #1,X,B$,Y                                     
220 PRINT"1. beolvasas:" X,B$,Y                         
230 INPUT #1,X,B$,Y                                     
240 PRINT"2. beolvasas:", X,B$,Y                        
Ok                                                      
RUN                                                     
1. beolvasas:  1             1             1  
2. beolvasas:  3            12             3  
Ok                                            

MID$ (függvény):

egy rész-stringet ad vissza. Hívása: y$=MID$(x$,n[,m]) ; ahol y$ az x$ azon rész-stringje lesz, amely az n-dik pozíción kezdõdik és m karakter hosszú. 0 < n,m < 256 feltételnek teljesülnie kell.

10 A$="123456789asd"                                    
20 PRINT MID$(A$,3,5),MID$(A$,9,3)                      
Ok                                                      
RUN                                                     
34567         9as                                       

MKDIR (utasítás):

megegyezik a 'make directory' rendszer- paranccsal, vagyis alkönyvtár létesítésére használható. Hívása: MKDIR ut ; pl. MKDIR "sales\mike".

MKD$ (függvény):

duplapontos számkifejezést 8 byte-os stringbe konvertál. A belsõ ábrázolás tulajdonképpen nem változik, csak számból string típus lesz. Pl. y$=MKD$(x#).Lásd még PUT utasítást!

10 x#=123456789.12345#                                   
20 y$=mkd$(x#)                                           
30 PRINT y$,len(y$)                                      
RUN                                                      
jM_úóyk˘       8                                         

MKI$ (függvény):

egész típusú számkifejezést 2 byte-os stringbe konvertál. A belsõ ábrázolás tulajdonképpen nem változik, csak számból string típus lesz. Pl. y$=MKI$(x%).Lásd még PUT utasítást!

10 x%=12345                                              
20 y$=mki$(x%)                                           
30 PRINT y$, len(y$)                                     
RUN                                                      
90             2                                         

MKS$ (függvény):

valós típusú számkifejezést 4 byte-os stringbe konvertál. A belsõ ábrázolás tulajdonképpen nem változik, csak számból string típus lesz. Pl. y$=MKS$(x). Lásd még PUT utasítást!

10 x=12345.678                                           
20 y$=mks$(x)                                            
30 PRINT y$ ,len(y$)                                     
RUN                                                      
µ@Ä           4                                         

NAME (utasítás):

megegyezik a 'rename file' rendszerpa- ranccsal, tehát file átnevezésére használható. Hívása: NAME oldfile_name AS newfile_name ;

NEW (utasítás):

törli a memóriában levõ programot. Mellékesen lezárja az esetleg nyitott file-okat is.

OCT$ (függvény):

egész (decimális) számkifejezés oktális (8- as számrendszerbeli) megfelelõjét teszi stringbe. Pl. v$=OCT$(24).

10 x=64                                                 
20 x$=oct$(x)                                           
30 PRINT x$                                             
RUN                                                     
100                                                     

ON ERROR (utasítás):

hiba fellépése esetén elugrik a kijelölt címkére. Hívása: ON ERROR GOTO címke. Ld. még a RESUME utasítást.

10 ON ERROR GOTO 100                                    
80 F$=123                                               
90 END                                                  
100 PRINT "Hibakod!";ERR;"A"; ERL;"programsorban!":RESUME 
1000 
Ok                                                      
RUN                                                     
Hibakod! 13 A 80 programsorban!                         

ON ... GOSUB (utasítás):

programkapcsoló utasítás. A felsorolt címkék közül annyiadikra ugrik (szubrutin- hívással), amit a kifejezés definiál. Hívása: ON kifejezés GOSUB címkelista.

10 INPUT "Hányadik rutin müködjön?",K                  
20 ON K GOSUB 50,80, 110                               
30 PRINT "Itt folytatódik."   ,X,Y,W                   
40 END                                                 
50 PRINT "1. rutin"                                    
60 X=X+1                                               
70 RETURN                                              
80 PRINT "2. rutin"                                    
90 Y=125                                               
100 RETURN                                             
110 PRINT "3. rutin"                                   
120 W=ATN(1)                                           
130 RETURN                                             
Ok                                                     
RUN                                                    
Hányadik rutin müködjön? 2                             
2. rutin                                               
Itt folytatódik.             0             125           0  

ON ... GOTO (utasítás):

a felsorolt címkék közül annyi- adikra ugrik, amit a kifejezés definiál. Programkapcsoló utasítás. Hívása: ON kifejezés GOTO címkelista.

10 INPUT "Legyen 1<=k<4 :",K                         
20 ON INT(K) GOTO 50 ,100,150                        
30 PRINT "Nincs visszatérés."                        
40 STOP                                              
50 PRINT "1. cím":END                                
100 PRINT "2. cím":END                               
150 PRINT "3. cím":END                               
Ok                                                   


RUN                                                  
Legyen 1<=k<4 :2                                     
2. cím                                               
Ok                                                   
RUN                                                  
Legyen 1<=k<4 :3.456                                 
3. cím                                               
Ok                                                   

OPEN (utasítás):

lehetõvé teszi file vagy eszköz megnyi- tását írásra illetve olvasásra. Kétféleképpen adható ki: OPEN filenév [FOR mode] AS [#]fileszám[,LEN=rekhossz] ahol mode={APPEND, INPUT, OUTPUT, RANDOM}, és LEN csak akkor definiálandó, ha a file random elérésû. OPEN mode, [#]fileszám, filenév [,rekhossz] ahol mode={A, I, O, R}, és rekhossz pontosan akkor definiálandó, ha mode=R. Filenév eszköz is lehet, pl. PRN:, LPT1:, COM1:, SCRN:, Lásd még INPUT , GET , PUT utasításokat! NUL: (ez az üres eszköz, tényleges transzfer nem történik). Ha az eszköz a kommunikációs csatorna (COM1: vagy COM2:), akkor a filenévben egyéb feltételeket is rögzítenünk kell: COMn:[v][,paritás][,adatbit][,stopbit][,RS][,CSn][,DSn][,CDn ][,LF][,PE] ahol v={75,110,150,300,600,1200,1800,2400,4800,9600} baud, paritás ={S,O,M,E,N}, adatbit ={5,6,7,8}, stopbit ={1,2} a CS, DS, CD opciók paraméterei millisec-ben értendõk, azaz ennyit vár a gép probléma esetén hibajelzés nélkül.

OPTION BASE (utasítás):

ezen utasítással jelölhetõ ki, hogy a továbbiakban definiált tömbök indexelése 0-val vagy 1-gyel kezdõdjön. Hívása: OPTION BASE n ; n={0,1}.

PEEK (függvény):

kiolvassa a memória adott byte-ját. Hívása: y=PEEK(x) ahol x a kért byte címének távolságát definiálja a DEFSEG utasításban meghatározott szegmens-címtõl.

10 DEF SEG=0                                           
20 PRINT  PEEK(1200)                                   
30 POKE 1200,65                                        
40 PRINT PEEK(1200)                                    
Ok                                                     
RUN                                                    
 0                                                     
 65                                                    

POKE (utasítás):

egy byte-ot ír a memóriába. Hívása: POKE n,m. Az m számot írja a memória azon byte-jába, melynek címe a DEFSEG definiálta szegmensen belül n. Lásd még PEEK utasítást! POS (függvény): visszaadja a cursor aktuális oszloppozí- cióját. Hívása: v=POS(0). Ld. még CSRLIN címszónál!

PRINT (utasítás):

képernyõre ír. Hívása: PRINT kifejezés- lista[;]. Az egyes kifejezések vesszõvel vagy pontosveszszõvel választandók el egymástól, ettõl függ, hogy a képen egymástól milyen távol íródnak. Ha az utolsó listaelemet is vesszõ vagy pontosvesszõ követi, akkor a következõ PRINT nem kezd új sort, hanem az elõzõt folytatja, feltéve, hogy tudja (ld. még a WIDTH utasítást).

10 PRINT "a","B";"C";                                 
20 PRINT "Nincs uj sor."                              
RUN                                                   
a             BCNincs uj sor.                         

PRINT USING (utasítás):

funkciója mint a PRINT-nek, de a nyomtatási kép jobban befolyásolható (pl. hány jegy pontosan írjunk ki egy számot). Hívása: PRINT USING v$;kifejezés-lista[;]. A v$ string tartalmazza a formázási parancsot; string mezõk: ! csak a string elsõ karakterét nyomtassa, \n szóköz\ a string n+2 karakterét nyomtassa, & a string teljes hosz- szában nyomtatásra kerül, szám mezõk: # számjegy pozíció jelölése - mindig kitöltõdik, + hatására a szám (kezdõ vagy záró) elõjellel kerül nyomtatásra, a jelnek a formátum string elején vagy végén kell állnia!

-

a formátum string végére írandó, hatására a negatív számok végére íródik az elõjel.

**

hatására a számkezdõ szóközök csillaggal töltõdnek fel - a formátum hosszába is beszámít!

$$

hatására a közvetlenül a kiírt szám elé egy '$' jel íródik.

,

ha a tizedesponttól balra szerepel, akkor a kiírt számba 3 tizedes jegyenként egy vesszõ kerül. Ha a vesszõ a formátum string végén szerepel, akkor egyszerûen a szám után íródik.

^^^^

hatására (a formátum string végén) a szám exponen- ciális formában kerül kijelzésre.

_

hatására a formátum string következõ karaktere közvetlenül kiírásra kerül.

10 A$="KONYV" :A=55 :DB=22                            
20 PRINT USING "Tétel:\     \ Ar:###.##Ft Mennyiség:"+ 
           "**# Erték:**####,.##Ft";A$,A,DB,A*DB       
RUN                                                    
Tétel:KONYV   Ar: 55.00Ft Mennyiség:*22 
Erték:**1,210.00Ft                      

PRINT# (utasítás):

ugyanaz, mint a PRINT, csak nem a kép- ernyõre kerül a lista, hanem az adott számon megnyitott file-ba. Hívása: PRINT# fileszám, kifejezés-lista[;].

PRINT# USING (utasítás):

ugyanaz, mint a PRINT USING, csak nem a képernyõre kerül a lista, hanem az adott számon megnyitott file-ba. Hívása: PRINT#fileszám,USING v$;kifejezés-lista[;].

PUT (utasítás):

egy rekordot ír a random (véletlen elérésû) file-ba. Hívása elõtt ne felejtsük el feltölteni a FIELD utasítással kijelölt buffert. Hívása: PUT#fileszám[,rekordsorszám] Ha a rekordsorszám opciót elhagyjuk, akkor a soron követ- kezõ rekordba ír (mint szekvenciális file-nál). Ha az utasítást COMn eszközre használjuk, akkor az opcionális paraméter nem rekordsorszámot jelent, hanem az utasítással kiírandó byte-ok számát - de ez nem lépheti túl az OPEN-ben elõírt rekordhosszat.

10 OPEN "R",#1,"vletlen.fle",40                           
20 FIELD #1,10 AS NEV$,15 AS SZEMSZ$,5 AS IR$,5 AS BER$   
30 FOR I=1 TO 4                                           
40 INPUT "NEV,SZEMELYSZ,IRANYITOSZ,BER",N$,SZ#,I%,B       
50 LSET NEV$=N$:LSET SZEMSZ$=MKD$(SZ#):LSET IR$=MKI$(I%)  
60 LSET BER$=MKS$(B)                                      
70 REM A FIELD mezokre nem tortenhet beolvasas.           
80 REM Ezert hasznaljuk LSET utasitast.                   
90 REM Randomfile-ba csak stringet irhatunk.              
100 REM Ezert hasznaljuk mki$-t,mks$-t.mkd$-t.            
110 PUT #1,I                                              
115 REM Az i. rekord feltoltese                           
120 NEXT I                                                
Ok                                                        
RUN                                                       
NEV,SZEMELYSZ,IRANYITOSZ,BERHorvat,28308122345,9000,625.7 
NEV,SZEMELYSZ,IRANYITOSZ,BER Szabo,28305153456,8000,675.5 
NEV,SZEMELYSZ,IRANYITOSZ,BER Molnar,18201175678,8777,99.9 
NEV,SZEMELYSZ,IRANYITOSZ,BER Nemeth,28509234567,9400,88.8 

RANDOMIZE (utasítás):

a véletlenszám-generálás kezdõérté- kének kijelölését teszi lehetõvé. Hívása: RANDOMIZE n. Korlát: -32769 < n < 32768. Ha valódi véletlen sorozattal akarunk dolgozni, használjuk a kezdõérték-kijelöléshez a TIMER függvényt.

READ (utasítás):

Funkciója: adatbeolvasás DATA sorokból, és változókhoz rendelése. Hívása: READ változólista. Hibajelzést akkor kaphatunk, ha az éppen beolvasott adat típusa nem egyezik a változó típusával, illetve ha a DATA sorokból az adatok elõbb elfogynak, mint a változók. Ld. még a RESTORE utasítást!

10 DATA 1,2,6,8,10 ,"A","B",12c",2.7,123456.987651#     
20 DATA 1.419,5.678                                     
30 READ A,B,C,D%,E%                                     
40 READ F$,G$                                           
50 READ H$,J,K#,L,M                                     
60 REM Minden változó azt a DATA elemet kapja értékül   
      ,melynek sorszáma a leírás sorrendjében ugyanaz   
      ,mint a változó sorszáma a leírás sorrendjében.   
70 REM Mindkét sorszám független attól,hogy hány DATA-ban 
       ,ill READ-ben történik a leírás.                 
120 RESTORE 20                                          
130 READ N,P                                            
140 PRINT A,B,C,D%                                      
150 PRINT E%,F$,G$                                      
160 PRINT H$,K#,J                                       
170 PRINT L,M,N,P                                       
RUN                                                     
 1             2             6             8            
 10           A             B                           
12c"           123456.987651               2.7          
 1.419         5.678         1.419         5.678        

REM (utasítás):

Hatása: az utasítás mögötti részt a BASIC már nem értelmezi, megjegyzésnek nyilvánítja. Helyettesít- hetõ a ' jellel is - kivéve a DATA sorokat!

RENUM (utasítás):

átsorszámozza a BASIC programot. Hívása: RENUM [kezdõ sorszám][,[induló sorszám],növekmény] A programot az 'induló sorszám' sorától kezdve átsorszá- mozza úgy, hogy az elsõnek átírt sor új sorszáma 'kezdõ sorszám' legyen, és a sorszámok egyenletesen, a 'növekménnyel' nõjenek. A 'kezdõ sorszám' és a 'növekmény' alapértelmezése 10, az 'induló sorszám 'kezdõértéke pedig a program elsõ sora.

RESTORE (utasítás):

a READ utasítás pointerét egy másik BASIC sorra állítja, vagyis segítségével felülbírálható a DATA sorok beolvasásának sorrendje. Hívása: RESTORE [sorszám]; ahol 'sorszám' alapértelmezése a program elsõ sora.

RESUME (utasítás):

Ha hiba hatására a program egy ON ERROR GOTO ... utasítást hajt végre, akkor a hibakezelõ programrészt a RESUME utasítással kell lezárni, mellyel elõírhatjuk, hol folytatódjék a program: RESUME 0; a program a hibás utasításon folytatódik, RESUME NEXT; a program a hibás utasítást követõ utasításon folytatódik, RESUME sorszám; a program a megjelölt sorszámú utasításnál folytatódik.

RETURN (utasítás):

GOSUB utasítással meghívott program- részletbõl ezen utasítással térhetünk vissza a hívás he- lyére (vagy az elõírt sorszámú utasításra). Alkalmazása:RETURN [sorszám].

RIGHT$ (függvény):

Hívása:y$=RIGHT$(x$,n). Funkciója: y$-ba teszi az x$ n hosszú jobboldali rész-stringjét.

10 A$="123456asdf"                                     
20 PRINT RIGHT$(A$,3),RIGHT$(A$,6)                     
                                                       
RUN                                                    
sdf           56asdf                                   

RMDIR (utasítás):

megegyezik a 'remove directory' rendszerparanccsal, tehát meglevõ (de üres) alkönyvtár törlésére használható. Hívása: RMDIR ut ; pl. RMDIR "\sales\mike".

RND (függvény):

{0,1}-beli, egyenletes eloszlású véletlen számot ad vissza. Ha az argumentuma 0, akkor az elõzõ hívás eredményét ismétli meg, egyébként pedig a leprogramozott sorozat következõ tagját szolgáltatja (hogy a sorozat honnan induljon, az a RANDOMIZE utasítással szabályozható).

10 INPUT"Adjon meg egy egesz szamot!", K%               
20 RANDOMIZE K%                                         
30 PRINT RND(0),RND(0),RND(0)                           
40 FOR I=1 TO 3                                         
50 PRINT  RND(I);                                       
60 NEXT I                                               
RUN                                                     
Adjon meg egy egesz szamot!5                            
 .524762       .524762       .524762                    
 3.537536E-02  .9370679  .8688921                       
Ok                                                      
RUN                                                     
Adjon meg egy egesz szamot!9                            
 .5870789      .5870789      .5870789                   
 .6609247  .62292  .1238359                             

RSET (utasítás):

mint az LSET, de most jobbra tömörít, és a baloldalt egészíti ki szóközzel.

RUN (utasítás):

programindító utasítás, több formában is kiadható: RUN [sorszám]; elindítja a memóriában levõ programot (az elõírt utasítástól vagy) elölrõl, RUN filenév[,R]; betölti a kijelölt programot és elindítja. Ha megadtuk az R opciót, akkor a nyitott file-okat nem zárja le.

SAVE (utasítás):

file-ba menti a memóriában levõ BASIC programot. Hívása: SAVE filenév [,A][,P]. Ha megadjuk az ',A' opciót, akkor a program ASCII formátumban kerül men- tésre (vagyis más szövegszerkesztõvel is tanulmányozható marad), és csak az így mentett file lehet késõbb MERGE u- tasítás paramétere! Ha a 'P' opciót használjuk, akkor a program újratöltés után már csak futtatható lesz, de belenézni, javítani már nem lehet, mert titkosított (protec- ted)!

SGN (függvény):

az argumentum elõjelfüggvénye. Hívása: v=SGN(x).

10 x=-4.2 :y=0 :z=4.2                                 
20 PRINT sgn(x),sgn(y),sgn(z)                         
RUN                                                   
-1             0             1                        

SHELL (utasítás):

segítségével léphetünk ki az operációs rendszer szintjére egy parancs küldésének erejéig. Hívása: SHELL parancs ; Problémát okozhatnak a már megnyitott file- ok, és ha BASIC programunk vagy a meghívott parancs túl sok memóriát igényel. Pl. SHELL "copy a: b:".

SIN (függvény):

szinuszfüggvény számítás, pl. y=SIN(x), ahol x radiánban értendõ!

10 PRINT 2*SIN(4*ATN(1)/3)                            
Ok                                                    
RUN                                                   
 1.732051                                             

SPACE$ (függvény):

elõírt hosszú, csupa szóköz stringet gyárt. Hívása: v$=SPACE$(n).

10 PRINT "AKARMI"+space$(5)+"valami"                  
RUN                                                   
AKARMI     valami                                     

SPC (függvény):

a PRINT utasításban alkalmazható, hatására a nyomtatófej n pozíciót (szóközt) elõre lép. Hívása: PRINT ...;SPC(n);...

10 PRINT "1234567890";spc(10);"1234567890"           
20 PRINT spc(10);"1234567890"                        
RUN                                                  
1234567890          1234567890                       
          1234567890                                 

SQR (függvény):

négyzetgyök függvény. Hívása: v=SQR(x).

10 a=1:c=2:b=4                                       
20 PRINT "DISZKRIMINANS",sqr(b^2-4*a*c)              
RUN                                                  
DISZKRIMINANS  2.828427                              

STEP (utasítás):

ld. a FOR utasítást!

STOP (utasítás):

megszakítja a program futását, és áttér parancs üzemmódba. Az END-tõl eltérõen a nyitott file-okat nem zárja le, és a program a CONT utasítással újraindítható.

STR$ (függvény):

az argumentumában szereplõ kifejezés string-képét adja vissza. Hívása: v$=STR$(kifejezés).

10 x=127.48:v$=str$(x)                               
20 PRINT str$(x)+space$(5)+v$                        
RUN                                                  
 127.48      127.48                                  

STRING$ (függvény):

Hívása: v$=STRING$(n,m) vagy v$=STRING$(n,x$) n hosszú, azonos (m ASCII kódu vagy x$) karakterekbõl álló stringet hoz létre.

10 PRINT string$(10,65),string$(7,"A")              
RUN                                                 
AAAAAAAAAA    AAAAAAA                               

SWAP (utasítás):

felcseréli két változó tartalmát. Hívása: SWAP változó1, változó2; feltétel, hogy a változók azonos típusúak legyenek!

10 x=121:y=442                                     
20 swap x,y                                        
30 PRINT "x="x,"y="y                               
RUN                                                
x= 442        y= 121                               

SYSTEM (utasítás):

hatására a vezérlés kilép a BASIC-bõl, és visszaadódik az operációs rendszernek. A megnyitott file- okat lezárja, a memóriában található program elveszik.

TAB (függvény):

PRINT utasításban alkalmazható a nyomtatási pozíció kijelölésére, pl. PRINT TAB(N);

10 FOR I=0 TO 5                                   
20 PRINT TAB(20-I) STRING$(I*2+1,"X")             
30 NEXT I                                         
RUN                                               
                   X                              
                  XXX                             
                 XXXXX                            
                XXXXXXX                           
               XXXXXXXXX                          
              XXXXXXXXXXX                         
Ok                                                

TAN (függvény):

tangensfüggvény számítás, pl. y=TAN(x), ahol x radiánban értendõ!

10 PRINT TAN(ATN(1)),TAN(4*ATN(1)/3)               
RUN                                                
 1             1.732052                            

TIME$ (függvény):

a rendszeróra állását adja vissza hh:mm:ss formában (óra:perc:sec). Pl. v$=TIME$.

10 v$=time$                                        
20 PRINT v$                                        
RUN                                                
13:32:16                                           

TIMER (függvény):

az éjfél (vagy az utolsó system reset) óta eltelt idõt adja vissza másodpercben, két tizedes jegyre.

10 PRINT timer                                     
RUN                                                
 12543.88                                          
Ok                                                 
RUN                                                
 12559.75                                          
Ok                                                 
RUN                                                
 12584.58                                          

TRON (utasítás):

bekapcsolja a nyomkövetést, azaz a parancs kiadása után a programfutás a képernyõn nyomon követhetõ, mert az éppen végrehajtott utasítás sorszáma kiíródik.

TROFF (utasítás):

kikapcsolja a nyomkövetést.

VAL (függvény):

egy stringben tárolt szám numerikus értéket adja vissza. Hívása: v=VAL(x$).

10 x$="1234.56"                                   
20 xv=val(x$)                                     
30 PRINT xv                                       
RUN                                               
 1234.56                                          

VARPTR (függvény):

visszaadja egy változó címének offset (eltolás) részét az aktuális memória-szegmenshez viszo- nyitva.

10 x=127.5 :y=237                                 
20 PRINT varptr(x),varptr(y)                      
RUN                                               
 3056          3064                               

WEND (utasítás):

ld. a WHILE utasítást!

WHILE (utasítás):

ciklikusan hajt végre egy WHILE és WEND közötti utasítás-sorozatot, mindaddig, mig a WHILE-ban elõírt feltétel igaz. Hívása: WHILE kifejezés ..... WEND

10 WHILE I<10                                     
20 PRINT "Ez a ciklusmag",I                       
30 I=I+3                                          
40 WEND                                           
50 PRINT "Lejart a ciklus",I                      
RUN                                               
Ez a ciklusmag               0                    
Ez a ciklusmag               3                    
Ez a ciklusmag               6                    
Ez a ciklusmag               9                    
Lejart a ciklus              12                   

WIDTH (utasítás):

beállítja az output eszköz sorszélességét (ennek elérése után automatikusan soremelés történik). Hívása: WIDTH hossz vagy WIDTH fileszám,hossz vagy WIDTH eszköz,hossz ; ahol eszköz lehet: SCRN:, PRN:, LPT1:, LPT2:, COM1:, COM2:.

WRITE (utasítás):

lényegében úgy mûködik, mint a PRINT, csak a kiírt számok közé vesszõt tesz, a stringeket pedig idézõjelbe írja. Hívása: WRITE kifejezéslista.

10 x=115:y#=123457.98765#:y$="qwe"                
20 write "Ez megjegyzes .",x,y#,y$                
RUN                                               
"Ez megjegyzes .",115,123457.98765,"qwe"          

WRITE# (utasítás):

ld. WRITE, de a lista nem képernyõre, hanem egy megnyitott file-ra (eszközre) kerül. Hívása: WRITE# fileszám, kifejezés-lista.

Hibakódok és üzenetek

1. NEXT without FOR; a NEXT utasításnak nincs FOR párja, a ciklusba a vezérlés nem a ciklus kezdõ utasításán át ke-rült.
2. Syntax error; a READ utasítás számváltozóba nem tud stringet olvasni.
3. RETURN without GOSUB; a program GOSUB utasítás nélkül jutott egy szubrutin belsejébe.
4. Out of data; a READ utasítás nem tud végrehajtódni, mert elfogytak a DATA sorokba írt adatok.
5. Illegal function call; mindannyiszor ez a hibajelzés, valahányszor egy függvényt vagy utasítást hibás (rossz típus vagy érték) paraméterekkel próbálunk meghívni.
6. Overflow; Az aritmetikai mûvelet eredménye túllépte a változó típusának megfelelõ határértéket.
7. Out of memory; elfogyott a szabad memória-terület: ez a hibajelzés sokféleképpen jöhet létre, pl. tömbdeklarációnál is.
8. Undefined line number; a program egy olyan címkére hivatkozik (pl. egy GOTO utasításban), amilyen nem léte-zik.
9. Subscript out of range; egy tömbelemre hivatkozáskor túl nagy indexet használtunk, ami nem felel meg a tömbdeklaráló DIM utasításnak.
10. Duplicate definition; ismételten megpróbáltunk egy tömböt deklarálni anélkül, hogy elõzõleg az ERASE utasítással töröltük volna.
11. Division by zero; nullával való osztást kíséreltünk meg.
12. Illegal direct; parancsmódban próbált olyan utasítást kiadni, amit csak programba lehet írni (pl. DEF FN).
13. Type mismatch; olyan helyen használtunk stringkifejezést, ahol számot kellett volna, vagy fordítva.
14. Out of string space; elfogyott a stringeknek biztosított tárterület.
15. String too long; a keletkezett string túl hosszú.
16. String formula too complex; a stringkifejezés túl hosszú vagy bonyolult, daraboljuk fel egyszerûbb értékadásokra.
17. Can't continue; a CONT utasítás nem végrehajtható, a program csak RUN utasítással indítható újra.
18. Undefined user function; a megfelelõ DEF FN függvény- definíció végrehajtása elõtt hívtuk meg a függvényt.
19. No RESUME; a fellépett hiba lekezelése közben a futás elérte a program végét, anélkül, hogy RESUME utasítással találkozott volna.
20. RESUME without error; a program úgy lépett be a hibafeldolgozó rutinba, hogy elõtte nem volt hiba.
21. Unprintable error; nincs hibaüzenet egy létezõ hibafeltételhez általában az ERROR utasítás okozza, ha ismeretlen hibakóddal paraméterezzük.
22. Missing operand; a kifejezésbõl hiányzik egy operandusz.
23. Line buffer overflow; a begépelt sor túl hosszú.
24. Device timeout; egy I/O utasítás közben a megnevezett eszköz nem válaszolt idõben.
25. Device fault; hardware jellegû hiba lépett fel valamely perifériánál (soros vagy párhuzamos interfésznél).
26. FOR without NEXT; a program futása elérte az utolsó sort, anélkül, hogy egy nyitott FOR ciklus lezárult volna.
27. Out of paper; a nyomtatóból kifogyott a papir, vagy be sincs kapcsolva.
28. WHILE without WEND; a program futása elérte az utolsó sort, anélkül, hogy egy nyitott WHILE ciklus lezárult volna.
29. WEND without WHILE; a WEND utasításnak nincs WHILE párja, a ciklusba a vezérlés nem a ciklus kezdõ utasításán át került.
30. Field overflow; a FIELD utasítás több byte-ot foglal, mint a hozzátartozó OPEN utasításban definiált rekordhossz.
31. Internal error; másold újra a lemezed, ellenõrizd a hardware-t, és jegyezd fel a hiba létrejöttének körülményeit.
32. Bad file number; a hivatkozott file még nincs megnyitva, vagy a fileszám túl nagy.
33. File not found; a névvel hivatkozott file nem létezik.
34. Bad file mode; lehet, hogy a file még nem lett megnyitva, vagy szekvenciálisnak lett megnyitva, de randomként próbáltuk használni.
35. File already open; egy már nyitott file-ot próbáltunk megnyitni (OPEN) vagy törölni (KILL).
36. Device I/O error; egy I/O mûvelet közben hiba lépett fel, amit a rendszer nem tud azonosítani.
37. File already exists; a NAME utasítás közben fordulhat elõ, ha az új név paraméter egy már létezõ file-ra mutat.
38. Disk full; a lemez megtelt, töröljük a felesleges file- okat.
39. Input past end; az olvasás már elérte a file végét.
40. Bad record number; negatív vagy túl nagy rekord- sorszámra hivatkozik a PUT vagy GET utasítás.
41. Bad file name; a hivatkozott filenév tiltott karaktereket is tartalmaz.
42. Direct statement in file; a beolvasandó programfile címkenélküli sort (utasítást) tartalmaz.
43. Too many files; ez a hibajelzés akkor fordulhat elõ, ha már túl sok file van a könyvtárban, vagy a rendszer nem fogadja el a file nevet.
44. Device unavailable; nemlétezõ eszközhözfordulás történt.
45. Communications buffer overflow; túlcsordult a kommunikációs buffer, sûrûbben kell kiolvasni, vagy hosszabbnak kell választani.
46. Permission denied; irásvédett lemezre próbáltunk írni.
47. Disk not ready; nyitva van a lemezegység ajtaja, vagy nincs is ilyen egység a gépben.
48. Disk media error; a lemez-vezérlõegység hibás szektort észlel.
49. Advanced feature; rossz (régi) BASIC verziót használunk.
50. Rename across disks; a file átnevezést nem lehet file- mozgatásra használni.
51. Path/File access error; hibás az útnév, vagy még aktív alkönyvtárat próbáltunk törölni.
52. Path not found; nemlétezõ útnév.
53. Child process error; a SHELL utasítással elindított procedúra megszakadt, hiba vagy megszakítás miatt.

ASCII kódtáblázat

 000     NUL    032  (szóköz)  064  @         096  ` 
 001     SOH    033  !         065  A         097  a 
 002     STX    034  "         066  B         098  b 
 003     ETX    035  #         067  C         099  c 
 004     EOT    036  $         068  D         100  d 
 005     ENQ    037  %         069  E         101  e 
 006     ACK    038  &         070  F         102  f 
 007     BEL    039  '         071  G         103  g 
 008     BS     040  (         072  H         104  h 
 009     HT     041  )         073  I         105  i 
 010     LF     042  *         074  J         106  j 
 011     VT     043  +         075  K         107  k 
 012     FF     044  ,         076  L         108  l 
 013     CR     045  -         077  M         109  m 
 014     SO     046  .         078  N         110  n 
 015     SI     047  /         079  O         111  o 
 016     DLE    048  0         080  P         112  p 
 017     DC1    049  1         081  Q         113  q 
 018     DC2    050  2         082  R         114  r 
 019     DC3    051  3         083  S         115  s 
 020     DC4    052  4         084  T         116  t 
 021     NAK    053  5         085  U         117  u 
 022     SYN    054  6         086  V         118  v 
 023     ETB    055  7         087  W         119  w 
 024     CAN    056  8         088  X         120  x 
 025     EM     057  9         089  Y         121  y 
 026     SUB    058  :         090  Z         122  z 
 027     ESC    059  ;         091  [         123  { 
 028     FS     060  <         092  \         124  | 
 029     GS     061  =         093  ]         125  } 
 030     RS     062  >         094  ^         126  ~ 
 031     US     063  ?         095  _         127