close

Commodore BASIC

Ugrás a navigációhoz Ugrás a kereséshez
Commodore BASIC
Commore 64 kezdőképernyő Commodore BASIC V2-vel.
Fejlesztő(k)
Microsoft
Általános információ
Megjelent 1977
Tervezte Microsoft
Legújabb stabil verzió V7.0 (1985)
MegvalósításokPET -ről C128- ra
Engedély nyomort okozó

A Commodore BASIC , más néven PET BASIC vagy CBM-BASIC , a Commodore International 8 bites otthoni számítógépeinek sorozatában használt BASIC programozási nyelv dialektusa , amely az 1977-es PET -től az 1985 -ös C128 -ig terjed.

A mag a Microsoft BASIC 6502 -re épül , és mint ilyen, számos olyan funkcióval rendelkezik, mint a többi korabeli BASIC 6502, mint például az Applesoft BASIC . A Commodore 1977-ben "egyszeri, jogdíjmentes" alapon licencelte a BASIC-ot a Microsofttól , miután Jack Tramiel elutasította Bill Gates egységenkénti 3 dolláros (2022-ben 13,42 dollár) díjazási ajánlatát , mondván: "Már házas vagyok." és legfeljebb 25 000 dollárt (2022-ben 111 793 dollárt) fizetne egy örökös licencért. [ 1 ]

A PET eredeti verziója kevés módosítással nagyon hasonlított az eredeti Microsoft implementációhoz. A BASIC 2.0 a C64-en is hasonló volt, és néhány C128-on és más modelleken is látható volt. A későbbi PET-ek a BASIC 4.0-t implementálták, hasonlóan az eredetihez, de egy sor parancsot hozzáadtak a floppy -val való munkavégzéshez .

A BASIC 3.5 volt az első, amely valóban elment a pályáról, számos parancsot hozzáadva a grafikus és hangtámogatáshoz a C16 -on és a Plus/4 -en . A BASIC 7.0 a Commodore 128-hoz tartozott, és a Plus/4 BASIC 3.5-ös verziójából származó strukturált programozási parancsokat, valamint kifejezetten a gép új képességeinek kihasználására tervezett kulcsszavakat tartalmazott. Sprite szerkesztő és gépi nyelvfigyelő hozzáadva. Az utolsó, a BASIC 10.0 a kiadatlan Commodore 65 része volt.

Előzmények

A Commodore átvette a BASIC forráskódját, és házon belül fejlesztette ki az összes többi 8 bites otthoni számítógépéhez. Egészen addig, amíg a Commodore 128 (V7.0-val) nem jelent meg a Microsoft szerzői jogi megjegyzése. A Microsoft azonban beépített egy easter egget a Commodore Basic 2. verziójába, amely bizonyította eredetét: a (homályos) parancs beírása WAIT 6502, 1azt eredményezte, hogy az Microsoft!megjelenik a képernyőn. (A húsvéti tojás jól el volt homályosítva: az üzenet egyetlen tolmács szétszerelésben sem jelent meg .) [ 2 ]

A népszerű Commodore 64 a BASIC v2.0-t implementálta ROM-ban, annak ellenére, hogy a számítógép a PET/CBM sorozat 4.0-s verziója után jelent meg, mert a 64-et otthoni számítógépnek szánták, míg a PET/CBM sorozatot kereskedelmi és oktatási célokra szánták. ott használja, ahol a beépített programozási nyelvét a legtöbbször kellett volna használni. Ez megtakarította a gyártási költségeket, mivel a V2 kisebb ROM-okba is belefér.

Technikai részletek

Programok szerkesztése

A ROM -on rezidens BASIC interpreter és a KERNAL kényelmes funkciója a teljes képernyős szerkesztő volt . [ 3 ] ​[ 4 ]​ Bár a Commodore billentyűzeteken csak két kurzorbillentyű van , amelyek a Shift billentyű lenyomásakor váltogatják az irányt, a képernyőszerkesztő lehetővé tette a felhasználók számára, hogy közvetlen parancsokat adjanak be, vagy programsorokat írjanak be és szerkesszenek a képernyő bármely pontjáról. Ha egy sor előtagja sorszámmal volt ellátva, akkor azt " tokenizálták ", és a program memóriájában tárolták. A nem számmal kezdődő sorokat a RETURN gomb megnyomásával hajtották végre, amikor a kurzor a soron volt. Ez jelentős előrelépést jelentett a programbeviteli interfészekben az akkoriban elterjedt otthoni számítógépes BASIC-ekhez képest, amelyek általában sorszerkesztőt használtak , amelyet külön paranccsal hívtak meg, vagy egy "kurzor másolása" parancsot, amely a kurzor pozíciójában lévő sort csonkolta. EDIT

Ezenkívül képes volt elnevezett fájlokat bármilyen eszközre menteni, beleértve a kazettát is, amely a PET napjaiban népszerű tárolóeszköz volt, és amely a 8 bites Commodores egész élettartama alatt használatban maradt, mint olcsó tömegtárolási forma. A legtöbb rendszer csak a floppy fájlneveket támogatta , ami megnehezítette több fájl mentését más eszközökre. Az egyik ilyen rendszer felhasználójának fel kellett jegyeznie a fájl helyét a felvevő számlálójában, de ez pontatlan és hibás volt. A PET (és a BASIC 2.0) esetén a kazettás fájlokat név szerint lehetett kérni. Az eszköz úgy keresi meg a fájlnevet, hogy egymás után olvassa az adatokat, figyelmen kívül hagyva a nem egyező fájlneveket. A fájlrendszert egy hatékony rendszerleíró adatbázis is támogatta, amely betölthető vagy fájlba menthető. A Commodore kazettán lévő adatokat digitálisan rögzítették, a más gyártók által használt olcsóbb (és kevésbé megbízható) analóg módszerek helyett. Ezért a szabványos magnó helyett speciális adatkészletre volt szükség. Rendelkezésre álltak olyan adapterek, amelyek analóg-digitális átalakítót használtak , hogy lehetővé tegyék egy szabványos magnó használatát, de ezek csak valamivel olcsóbbak, mint a Datasette.

A LOAD parancs az opcionális ,1 paraméterrel használható , amely a fájl első két bájtjában található memóriacímen tölt be egy programot (ezek a bájtok el lesznek távolítva, és nem tárolódnak a memóriában). Ha nem használjuk a ,1 paramétert, akkor a program a BASIC programterület elejére kerül betöltésre, ami gépenként nagyban eltér. A Commodore BASIC egyes változatai parancsokat biztosítottak , BLOADés BSAVEúgy működtek, mint az Applesoft BASIC megfelelői, bittérképeket töltve be vagy mentve meghatározott memóriahelyekről.

A PET nem támogatja az áthelyezhető programokat, és a LOAD parancs mindig a programfájlban található első két bájtot tölti be. Ez problémát okozott, amikor a mentett BASIC programokat más Commodore gépekre próbálták betölteni, mivel azok magasabb címre lennének betöltve, mint ahol a PET BASIC elvárta a programot, és voltak kerülő megoldások a programok megfelelő helyre "mozgatására". Ha egy programot egy CBM-II gépre mentettünk , akkor az egyetlen módja annak, hogy PET-re töltsük be, az volt, hogy az első két bájtot lemezszektor-szerkesztővel módosítjuk, mivel a CBM-II sorozat BASIC programterülete $0 volt, ami azt eredményezné, hogy a PET a nulladik oldalon próbál betölteni, és összeomlik.

A Commodore BASIC fenntartott szavak lerövidíthetők úgy, hogy először egy változatlan billentyűleütést, majd a következő betű megváltoztatott billentyűleütését írjuk be. Ez beállítja a magas bitet , ami miatt az értelmező leállítja az olvasást, és egy keresőtábla szerint elemzi az utasítást. Ez azt jelentette, hogy az utasítást a magas bit beállításáig elfogadták a teljes parancs kiírásának helyettesítőjeként. Mivel azonban az összes BASIC kulcsszót a memóriában egybájtos tokenként tárolták, ez inkább az utasítások bevitelének kényelmét szolgálta, mintsem az optimalizálást.

Az alapértelmezett, csak nagybetűs karakterkészletben az eltolt karakterek grafikus szimbólumként jelennek meg; pl. a , parancsot GOTOle lehet rövidíteni G{Shift-O}(ami úgy nézett ki, mint a képernyőn). A legtöbb parancs két betűből állt, de néhány esetben hosszabbak is voltak. Az ilyen esetekben félreérthető volt, ezért a parancsból több betűre volt szükség nagybetűk nélkül, például ( ), mint amennyi a parancshoz szükséges . Néhány parancsot nem rövidítettek le, akár a rövidség, akár a más parancsokkal való kétértelműség miatt. Például a parancsnak nem volt rövidítése, mert a helyesírása ütközött az elválasztott kulcsszóval , amely közelebb állt a megfelelőségi táblázatban a kulcsszó elejéhez . A széles körben használt parancsnak egyetlen parancsikonja volt, ahogy ez a Microsoft BASIC legtöbb dialektusában megszokott volt. A görgető betűket tartalmazó parancsrövidítés a Commodore BASIC egyedi jellemzője. GΓGO{Shift-S}GO♥GOSUBINPUTINPUT#PRINT?

Ennek a tokenizációs módszernek volt egy olyan hibája, hogy ha az egyikben szerepel egy REM(BASIC utasítás a kódhoz megjegyzés hozzáadására), majd egy {Shift-L}, amikor megpróbálja megtekinteni a programok listáját, a BASIC értelmező azonnal megszakítja a listát, megjeleníti a -t, ?SYNTAX ERRORés visszatér az üzenetet READY.. Ezt a hibát bizonyos mértékben a programozók használták fel, akik tesztelni akarták és meg akarták védeni a munkájukat, bár meglehetősen könnyű volt kijátszani.

A kulcsszavak lerövidítésével több kódot lehetett egyetlen programsorba illeszteni (amely 40 oszlopos képernyőkön, azaz C64-en vagy PET-en két sornyi képernyőt, a VIC 22 oszlopos képernyőjén pedig négy sort foglalhatott el) -húsz). Ez enyhe megtakarítást tett lehetővé a programsorok tárolásánál, amelyekhez egyébként további sorokra lett volna szükség. Minden BASIC parancs tokenizált, és 1 bájtot (több BASIC 7 vagy BASIC 10 parancs esetén kettőt) foglalt el a memóriában, függetlenül attól, hogy hogyan kerültek beírásra. Az ilyen hosszú sorok szerkesztése gondot okozott. A parancs LISTa teljes parancs kulcsszót jelenítette meg, kiterjesztve a programsort a programmemóriába beírható 2 vagy 4 képernyősoron túlra.

Teljesítmény

A Microsoft BASIC értelmezőhöz hasonlóan a Commodore BASIC is lassabb, mint a natív gépi kód . A teszteredmények azt mutatták, hogy 16 kilobájt ROM RAM-ba másolása kevesebb mint egy másodpercet vesz igénybe gépi kódban, szemben a BASIC-ben több mint egy perccel. [ idézet szükséges ] Az értelmezőnél gyorsabb végrehajtás érdekében a programozók különféle technikákat kezdtek használni a végrehajtás felgyorsítására. Az egyik az volt, hogy a gyakran használt lebegőpontos értékeket változókban tárolták a literális értékek helyett, mivel a változónév elemzése gyorsabb volt, mint a literális szám elemzése. Mivel a lebegőpontos az összes parancs alapértelmezett típusa, gyorsabb a lebegőpontos számok használata argumentumként, nem pedig egész. Amikor a gyorsaság fontos volt, egyes programozók a BASIC programok részeit 6502 vagy 6510 assembly nyelvre konvertálták , amelyet a fájlból külön töltöttek be, vagy a BASIC program végén lévő DATA utasításokból a memóriába helyezték, és a BASIC programból a parancs segítségével hajtották végre , vagy közvetlen módban vagy magából a programból . Ha a gépi nyelv végrehajtási sebessége túl nagy volt, például egy játékhoz, vagy ha felhasználói bevitelt vártak, a programozók a kiválasztott memóriahelyek beolvasásával tudták lekérdezni (például $C6 [ 5 ] 64 esetén vagy $ D0 [ 6 ] a 128-hoz, amely a billentyűzetsor méretét jelzi) a végrehajtás késleltetéséhez vagy leállításához. SYS

A Commodore BASIC egyedülálló funkciója a vezérlőkódok használata a programon belüli feladatok végrehajtására, mint például a képernyő törlése vagy a kurzor pozicionálása; ezeket egy paranccsal lehet előhívni, ahol X a kiadandó vezérlőkódnak felel meg (például ez a képernyő törlésének vezérlőkódja), vagy a kérdéses billentyű idézőjelek közé való lenyomásával, így a ⇧ Shift + CLR HOME lenyomásával . egy idézet megjeleníti a BASIC vezérlőkód (ebben az esetben egy fordított szív) vizuális megjelenítését, amelyre a program végrehajtása során reagál (a vezérlőkódok közvetlen kinyomtatása kevesebb memóriát használ, és gyorsabban fut, mint egy CHR$ függvény hívása ). Ez összehasonlítva a BASIC más megvalósításaival, amelyek jellemzően dedikált parancsokkal rendelkeznek a képernyő törlésére vagy a kurzor mozgatására. A BASIC 3.5 és újabb verziók speciális parancsokkal rendelkeznek a képernyő törlésére és a kurzor mozgatására. PRINT CHR$(X)PRINT CHR$(147)

A Commodore BASIC programsorai nem igényelnek szóközt sehol (de a LIST parancs mindig egyet mutat a sorszám és a deklaráció között), pl. , és gyakori volt, hogy szóköz nélkül írnak programokat. Ezt a funkciót a memória kímélése érdekében adták hozzá, mivel a tokenizátor soha nem távolítja el a kulcsszavak közé beszúrt szóközöket: a szóközök jelenléte extra bájtokat eredményez a tokenizált programban, amelyeket a program végrehajtása során egyszerűen kihagy. A tokenizátor eltávolítja a szóközt a sorszám és a programdeklaráció között. 100 IFA=5THENPRINT "YES":GOTO1600x20

A programsorok a legtöbb gépen összesen 80 karakter hosszúak lehetnek, de a 40 oszlopos szövegű gépeknél a sor a következő sorra kerülne a képernyőn, a VIC-20-on pedig, aminek képernyője 22 oszlop volt, a program sorok legfeljebb négyet foglalhatnak el. A BASIC 7.0 a Commodore 128-on 160 karakterre növelte egy programsor korlátját (négy sor 40 oszlopból vagy két sor 80 oszlopból). ?Ha a helyett olyan rövidítéseket használunk, mint a PRINT, akkor még több is szerepelhet egy sorban. A BASIC 7.0 ?STRING TOO LONG(túl hosszú karakterlánc) hibát jelez, ha a felhasználó 160 karakternél hosszabb programsort ír be. A korábbi verziók nem produkáltak hibát, és egyszerűen a READY üzenetet jelenítették meg két sorral lejjebb, ha a vonal hosszát túllépték. A sorszám a programsorban szereplő karakterek számába kerül beleszámításra, így egy ötjegyű sorszám négyel kevesebb megengedett karaktert eredményez, mint egy egyjegyű szám.

A Commodore BASIC sorok végrehajtási sorrendjét nem sorszámozás határozta meg; ehelyett azt a sorrendet követték, hogy a sorokat a memóriában összekapcsolták. [ 7 ] A programsorokat egyetlen linkelt listaként tároltuk a memóriában, egy pointerrel (amely tartalmazza a következő programsor elejének címét), egy sorszámot, majd a sor tokenizált kódját. A program bevitele közben a BASIC folyamatosan átrendezte a program sorait a memóriában, hogy a sorszámok és mutatók mind növekvő sorrendben legyenek. A programba való belépés után azonban a sorszámok és mutatók POKE parancsokkal történő manuális módosítása lehetővé teheti a soron kívüli végrehajtást, vagy akár ugyanazt a sorszámot is megadhatja minden sornak. A kezdeti időkben, amikor a BASIC-et kereskedelmi forgalomban használták, ez egy szoftveres védelmi technika volt , amely megakadályozta a program véletlenszerű módosításait.

A sorszámok 0-tól 65520-ig terjedhetnek, és öt bájtot vehet igénybe, függetlenül attól, hogy hány számjegy van a sorszámban, bár a végrehajtás gyorsabb, minél kevesebb számjegy van. Ha több utasítást tesz egy sorba, az kevesebb memóriát használ, és gyorsabban fut.

A GOTO és a GOSUB az aktuális sorból lefelé keres egy sorszámot, ha előreugrás történik, de visszaugrás esetén a keresés a program elejétől kezdődik. Ez lelassítja a nagyobb programokat, ezért célszerű a gyakran használt szubrutinokat a kezdés közelében elhelyezni.

A változónevek csak 2 karakterből állnak; ezért a változónevek VARIABLE1, VARIABLE2és VAmind ugyanarra a változóra utalnak.

A Commodore BASIC támogatja a bitenkénti ÉS , VAGY és XOR operátorokat is ; bár ez a funkció a Microsoft BASIC 6502 alapkódjának része volt, általában kimaradt más megvalósításokból, például az Applesoft BASIC -ból .

A Commodore BASIC natív számformátuma, akárcsak a szülő MS BASIC formátuma, lebegőpontos volt . A legtöbb kortárs BASIC megvalósítás egy bájtot használt a kitevőként és három bájtot a mantisszához . A három bájtos mantisszát használó lebegőpontos számok pontossága csak körülbelül 6,5 tizedesjegy, és gyakori a kerekítési hiba . A Microsoft BASIC 6502-es implementációi 40 bites lebegőpontos aritmetikát használtak, ami azt jelenti, hogy a változók tárolása öt bájtot igényelt (négy bájt a mantisszának és egy bájt a kitevőnek), szemben a 32 bites lebegőponttal, amelyet a BASIC-80 tartalmaz. .

Míg a Microsoft BASIC 8080/Z80-as implementációi támogatták a dupla pontosságú és az egész változókat, a 6502-es implementációk csak lebegőpontosak voltak.

Bár a Commodore BASIC támogatja az előjeles egész változókat (százalékjellel jelezve) a -32768 és 32767 közötti tartományban, a gyakorlatban csak tömbváltozókhoz használják, és memóriatakarékossági funkciót töltenek be azáltal, hogy a tömbelemeket egyenként két bájtra korlátozzák (egy tömb). 2000 elem 10 000 bájtot foglal el, ha lebegőpontos tömbként deklarálják, de csak 4 000-et, ha egész tömbként deklarálják). Ha bármely változót egész számként jelölünk, a BASIC egyszerűen lebegőpontossá alakítja vissza, ami lelassítja a program végrehajtását és pazarolja a memóriát, mivel minden százalékjelhez plusz bájt szükséges (mivel ez az egész számok tömbjére is vonatkozik, a programozónak ne használja őket, kivéve, ha nagyon nagy tömböket használnak, amelyek lebegőpontos tárolás esetén meghaladnák a rendelkezésre álló memóriát). Ezenkívül nem lehetséges POKE vagy PEEK memóriahelyek 32767 feletti előjeles egészként meghatározott címével.

A 0 helyett pont (.) is használható (tehát a helyett vagy helyett ), ez egy kicsit gyorsabban fog futni. 10 A=.10 A=010 FOR A=.TO 10010 FOR A=0 to 100

A Commodore hozzáadta a gépi nyelvű programok indítására használt SYS utasítást , és ez nem szerepelt a Microsoft eredeti BASIC kódjában, amely csak a gépi nyelvi rutinok meghívására szolgáló USR függvényt tartalmazta. A SYS utasítás automatikusan betölti a CPU-regisztereket $30C-$30F értékekkel (C64, más gépeken változik); ez használható adatok átadására a gépi nyelvi rutinoknak, vagy kernelfüggvények BASIC-ból való meghívására (például törli a képernyőt). POKE 780,147:SYS 65490

Mivel a nem C128-as 8 bites Commodore gépek nem tudják automatikusan elindítani a szoftvert lemezről, a szokásos technika egy BASIC csonk beépítése, például a program végrehajtásának elindítása. Lehetőség van a szoftver automatikus elindítására a betöltés után, és nem kell a felhasználótól RUN utasítást írni , ez egy kódrészlettel történik, amely a BASIC "ready" vektort bedugja a $0302 -be . 10 SYS 2048

A Microsoft BASIC legtöbb más verziójához hasonlóan, ha egy tömb nincs DIM utasítással deklarálva , akkor automatikusan tíz elemre lesz beállítva (a gyakorlatban 11, mivel a tömbelemek 0-tól számítanak). Nagyobb tömböket kell deklarálni, különben a BASIC hibát jelez, amikor a program fut, és a tömböt nem lehet átméretezni a programban, hacsak nem törli az összes változót egy CLR utasítás. A numerikus tömbök létrehozásukkor automatikusan nullákkal töltődnek fel, nagy tömb méretezése esetén a program végrehajtása pillanatnyi késéssel járhat.

A karakterlánc-változókat a változó nevének "$" jellel való címkézése jelenti. Ezért a AA$, AAés változókat AA%különállónak kell tekinteni. A tömbváltozók is különböznek az egyszerű változóktól, ezért A és A(1) nem ugyanarra a változóra utal. A karakterlánc tömb mérete egyszerűen arra utal, hogy hány karakterlánc van a tömbben tárolva, nem pedig az egyes elemek méretére, amelyek dinamikusan vannak lefoglalva. A Microsoft BASIC más megvalósításaival ellentétben a Commodore BASIC nem igényel karakterlánc-területet a program elején.

Más 8 bites gépekkel, például az Apple II-vel ellentétben, minden Commodore gép rendelkezik beépített órával, amely bekapcsoláskor 0-ra inicializálódik, és minden egyes PIA/VIA/TED/CIA időzítéssel frissül, tehát másodpercenként 60-szor. Két rendszerváltozó van hozzárendelve a BASIC-ben, a TI és a TI$ , amelyek az aktuális időt tartalmazzák. A TI csak olvasható, és nem módosítható; ha megteszi, szintaktikai hibaüzenet jelenik meg. A TI$ használható az idő beállítására egy hat számjegyből álló karakterláncon keresztül (hiba lép fel, ha hat számtól eltérő karakterláncot használ). Az óra nem túl megbízható időzítési módszer, mivel megáll minden alkalommal, amikor a megszakításokat letiltják (egyes kernelrutinok hajtják végre), és az IEC-porthoz (vagy a PET-en az IEEE-porthoz) való hozzáférés néhányszor késlelteti az órafrissítést. .

A Commodore BASIC RND funkciója az órát használja véletlen számok generálására; ezt az RND(0) valósítja meg , azonban viszonylag korlátozottan használható, mivel csak 0 és 255 közötti számokat ad vissza. Egyébként az RND ugyanúgy működik, mint a többi Microsoft BASIC implementáció, mivel egy szekvenciát pszeudo-véletlenszerűen használnak egy rögzített 5-ösön keresztül. -A bekapcsoláskor tárolt bájt magérték a $8B-$8F memóriahelyeken a C64-en (a hely más gépeken eltér). A 0-nál nagyobb számmal rendelkező RND véletlen számot generál az RND függvényben szereplő értékből és a kezdeti értékből, amely minden egyes RND függvény végrehajtásakor 1-gyel frissül. A negatív számmal rendelkező RND a szám által meghatározott aktuális magérték sorozatának egy pontjára megy.

Mivel a valódi véletlenszám generálása lehetetlen az RND utasítással , a C64 és C128 esetében gyakoribb, hogy az SID chip fehér zajcsatornáját használják véletlen számokhoz.

A BASIC 2.0 köztudottan szenvedett a rendkívül lassú szemétszedéstől. A szemétgyűjtés automatikusan elindul minden FRE függvény végrehajtásakor, és ha egy program során sok karakterláncváltozót és tömböt manipuláltak, a törlésük a legrosszabb körülmények között akár egy órát is igénybe vehet. A szemétgyűjtés megszakítása sem lehetséges, mivel a BASIC nem vizsgálja a RUN/STOP kulcsot a rutin végrehajtása közben. A BASIC 4.0 továbbfejlesztett visszafelé mutató szemétgyűjtő rendszert vezetett be, és az összes későbbi Commodore BASIC implementáció is rendelkezik ezzel.

A FRE függvény a BASIC 2.0-ban egy másik hibától szenvedett, mivel nem tudja kezelni a 32768-nál nagyobb előjeles számokat, így ha a függvényt C64-en hívják (38k BASIC memória), akkor a szabad BASIC memória negatív száma jelenik meg (hozzáadás 65535 a bejelentett számra a megfelelő mennyiségű szabad memóriát adja meg). A PET-nek és a VIC-20-nak soha nem volt több mint 32 000 teljes memóriája a BASIC számára, így ez a korlátozás csak a C64 kifejlesztéséig vált nyilvánvalóvá. A BASIC 3.5 és 7.0 FRE funkciója kijavította ezt a problémát, és a BASIC 7.0-ban a FRE szintén két függvényre lett "felosztva", az egyik a szabad BASIC program szövegmemóriájára, a másik pedig a szabad változó memória megjelenítésére.

Alternatívák

Image
Simons BASIC kezdőképernyője.

A Commodore 64-hez számos BASIC bővítményt adtak ki, a natív BASIC 2.0 viszonylag korlátozott képességei miatt. Az egyik legnépszerűbb bővítmény a DOS Wedge volt, amely a Commodore 1541 Test/Demo Disk -en kapott helyet . Ez a BASIC 1 KB-os bővítménye számos lemezzel kapcsolatos parancsot adott, beleértve a könyvtárak lemezről történő olvasását anélkül, hogy a program tönkretenné a memóriában. Funkcióit később beépítették különféle harmadik féltől származó bővítményekbe, például a népszerű Epyx Fast Load patronba . A BASIC egyéb bővítményei extra kulcsszavakat adtak hozzá, hogy megkönnyítsék a nagy felbontású grafikák, hangok és sprite-ok kódolását, mint például Simons BASIC .

Bár a BASIC 2.0 hang- és grafikai funkcióinak hiánya sok felhasználó számára frusztráló volt, egyes kritikusok azzal érveltek, hogy ez végső soron előnyös volt, mivel arra kényszerítette a felhasználót, hogy megtanulja a gépi nyelvet.

A BASIC 2.0 korlátai a C64-en a BASIC ROM-ba épített gépi nyelv használatához vezettek. Ha egy fájlt egy kijelölt memóriahelyre szeretne betölteni, a hívás beolvassa a fájl nevét, a meghajtót és az eszköz számát: ; [ 8 ]​ a hely az X és Y regiszterekben lenne megadva: ; [ 9 ]​ és a bootstrap a következővel lenne meghívva: . [ 10 ] SYS57812"filename",8POKE780,0:POKE781,0:POKE782,192SYS65493

A C64 lemezes magazinja, a Loadstar az amatőr programozók találkozási helye volt, akik megosztották a BASIC protoparancsainak gyűjteményét, és a parancsot hívták meg SYS dirección + desplazamiento.

Modern programozási szempontból a Commodore BASIC korábbi verziói számos rossz programozási trükköt mutattak be a programozó számára. Mivel a legtöbb probléma a Microsoft BASIC -ből ered , gyakorlatilag az összes akkori otthoni számítógép BASIC-je hasonló hiányosságoktól szenvedett. [ 11 ] A programozó egy sorszámot rendelt egy Microsoft BASIC program minden sorához. Általános gyakorlat volt, hogy a számokat valamilyen értékkel (5, 10 vagy 100) növelték, hogy megkönnyítsék a sorok beszúrását a programszerkesztés vagy hibakeresés során, de a rossz tervezés azt jelentette, hogy a nagy szakaszok programba való beillesztéséhez gyakran a teljes kód átstrukturálására volt szükség. Egy elterjedt technika az volt, hogy egy programot valamilyen alacsony sorszámon indítottak ON...GOSUB ugrótáblázattal , és a program törzsét szakaszokba rendezték, amelyek egy meghatározott sorszámmal kezdődnek, például 1000, 2000 stb. Ha egy nagy szakaszt kellett hozzáadni, egyszerűen hozzárendelhető a következő elérhető fősorszámhoz, és beilleszthető az ugrástáblázatba.

A Commodore és más platformok későbbi BASIC verziói tartalmaztak egy TÖRLÉS és ÚJRASZÁMÍTÁS parancsot , valamint egy AUTO sorszámozási parancsot, amely automatikusan kiválasztja és beilleszti a sorszámokat a kiválasztott növekménynek megfelelően. Ezenkívül az összes változót globális változóként kezeljük. Egyértelműen meghatározott hurkokat nehéz létrehozni, ezért a programozó gyakran a GOTO parancsra hagyatkozik (ezt később a BASIC 3.5 javította a DO, LOOP, WHILE, UNTIL és EXIT hozzáadásával ). Bizonyos feladatok végrehajtásához gyakran jelzőváltozókat kellett létrehozni. A korábbi Commodore BASIC-ekből szintén hiányoznak a hibakeresési parancsok, ami azt jelenti, hogy a hibákat és a nem használt változókat nehéz megtalálni. A Microsoft BASIC Z80 szabvány részét képező IF...THEN...ELSE struktúrákat hozzáadták a BASIC 3.5-höz, miután a Commodore BASIC korábbi verzióiban elérhetetlenné váltak.

Használja felhasználói felületként

Más otthoni számítógépekhez hasonlóan a Commodore gépei is közvetlenül a BASIC tolmácsra indultak. A BASIC programozási és fájlparancsok közvetlen módban adhatók meg a szoftver betöltéséhez és futtatásához. Ha a program végrehajtását a RUN/STOP billentyűvel leállítjuk, a változók értékei a RAM-ban maradnak, és a PRINT paranccsal lekérdezhetők hibakereséshez. A 128 még a második 64 000-os bankját is a változó tárolására szánta, lehetővé téve az értékek fennmaradását a NEWvagy parancs kiadásáig RUN. Ez a Commodore BASIC-hez tartozó fejlett képernyőszerkesztővel együtt REPL -szerű érzést adott a programozási környezetnek ; A programozók a képernyő bármely pontjára beilleszthettek és szerkeszthetnek programsorokat, interaktív módon létrehozva a programot. [ 12 ] Ez ellentétben áll a korabeli üzletorientált operációs rendszerekkel, mint például a CP/M vagy az MS-DOS , amelyek általában parancssori felületről indultak el . Ha ezeken a platformokon programozási nyelvre volt szükség, azt külön kellett feltölteni.

Míg a Commodore BASIC egyes verziói tartalmaztak lemezspecifikus DLOADy parancsokat, a Commodore 64DSAVE - be beépített verzióból ezek hiányoztak, ezért a felhasználónak meg kellett adnia a lemezmeghajtó eszközszámát (általában 8 vagy 9) a szabványos parancsban , amely egyébként a kazetta lenne. A Commodore 64 BASIC 2.0 másik hiányossága egy olyan parancs volt , amely a lemez tartalmát a fő memória törlése nélkül jelenítette meg. 64-ben a fájlok lemezen való megjelenítését egy "program" betöltéseként valósították meg, amely a listában pszeudo BASIC programként jelenítette meg a könyvtárat, sorszámként a fájl blokkméretével. Ez azzal a hatással járt, hogy felülírta a betöltött programot a memóriában. Az olyan beépülő modulok, mint a DOS Wedge, legyőzték ezt azáltal, hogy a könyvtárlistát közvetlenül a képernyőmemóriában jelenítették meg. LOADDIRECTORY

Verziók és funkciók

A CBM BASIC verzióinak listája időrendi sorrendben, egymás után hozzáadott szolgáltatásokkal:

Közzétett verziók

  • V1.0: PET 2001 Chiclet billentyűzettel és adatkészlettel (eredeti PET)
    • 256 elemre korlátozott tömbök
    • A PEEK parancs kifejezetten le van tiltva a BASIC ROM helyeken, ahol $C000 felett van
  • V2.0 (első kiadás): PET 2001 teljes utazó billentyűzettel és frissített ROM-mal
    • hozzáadja az IEEE-488 támogatást
    • javított szemétgyűjtés [ 13 ]
    • tömbhibát javítani
    • Húsvéti tojás: A WAIT6502,[szám]MICROSOFT! beírása tetszőleges számú alkalommal jelenik meg
  • V4.0: PET/CBM 4000/8000 sorozat (és a PET 2001 legújabb verziója)
    • lemezműveletek : DLOAD,DSAVE,COPY,SCRATCH,stb (összesen 15)
    • lemezhiba csatorna változók:DS,DS$
    • Jelentősen javult a szemétgyűjtési teljesítmény [ 13 ]
  • V2.0 (második verzió, 4.0 után): VIC-20 ; C64
  • V4+: CBM-II sorozat (más néven B, P tartomány)
    • memóriakezelés:BANK
    • további lemezműveletek :BLOAD, BSAVE, DCLEAR
    • formázott kijelző:PRINT USING, PUDEF
    • rögzítési hiba:DISPOSE
    • alternatív villa:ELSE
    • dinamikus hibakezelés:TRAP, RESUME, ERR$()
    • rugalmas olvasása DATA: RESTORE [sorszám]
    • karakterlánc kereső funkció:INSTR
  • V3.5: C16/116 , Plus/4
    • hang- és grafikai parancsok
    • joystick bemenet :JOY
    • decimális ↔ hexadecimális konverzió :DEC(),HEX$()
    • strukturált hurok:DO, LOOP, WHILE, UNTIL, EXIT
    • funkciógomb hozzárendelése: KEY(közvetlen módban is)
    • programok bevitele/szerkesztése:AUTO, DELETE, RENUMBER
    • hibakeresés (nyomkövetés):TRON, TROFF
    • MLM beviteli parancs :MONITOR
    • Easter Egg C(1)16, plusz/4: írja be: <code>SYS 52650</code>
  • V7.0: C128
    • több hang- és grafikai parancs, beleértve a sprite -kezelést is
    • integrált sprite szerkesztő:SPRDEF
    • több utasításblokk a struktúrákhoz IF THEN ELSE:BEGIN,BEND
    • lapát , ceruza :JARRO,PEN
    • Funkció vagy kizárólagos :XOR
    • kapja meg a változó címét:POINTER
    • ablakok szöveges módban:WINDOW
    • szabályozott késleltetési idő:SLEEP
    • memóriakezelés:SWAP, FETCH, STASH, FRE(1)
    • 128 bankváltás használata a programkód változóktól elkülönített tárolására. A változó értékek a programvégrehajtások során megmaradnak, ha a programot a GOTO paranccsal indították el.
    • további lemezműveletek :BOOT, DVERIFY
    • CPU-sebesség beállítása: FAST,SLOW(2 vs 1 MHz)
    • lépjen be C64 módba:GO64
    • nem dokumentált, működik: RREG(a CPU regisztereket olvassa be a ) után SYS)
    • nem megvalósított parancsok:OFF,QUIT
    • Easter Egg C128 – Belépés SYS 32800,123,45,6

Kiadatlan verziók

  • V3.6: Commodore LCD (nem publikált prototípus). Szinte megegyezik a V7.0-val, a következő eltérésekkel: [ 14 ]
    • VOLUMENahelyettVOL
    • EXITahelyettQUIT
    • parancsok FAST, SLOWnincsenek jelen
    • Kiegészítő parancs:POPUPS
  • V10: Commodore 65 (kiadatlan prototípus)
    • grafikus/videó parancsok:PALETTE, GENLOCK
    • egér bemenet :MOUSE, RMOUSE
    • szöveges fájl segédprogram ( SEQ):TYPE
    • programszerkesztés:FIND, CHANGE
    • memóriakezelés:DMA, FRE(2)
    • nem megvalósított parancsok:PAINT, LOCATE, SCALE, WIDTH, SET, VIEWPORT, PASTE, CUT

Figyelemre méltó bővítménycsomagok

  • Super Expander (VIC-20; ROM kazettán szállítva ) (Commodore)
  • Super Expander 64 (C64; patron) (Commodore)
  • Simons' Basic (C64; patron) (Commodore)
  • Graphics BASIC (C64; floppy) ( Hesware )
  • BASIC 8 (C128; hajlékonylemez és opcionális belső ROM chip) ( Walrusoft )

Lásd még

Hivatkozások

  1. ↑ Jack Tramiel tanúja a Commodore 64 25. évfordulójának ünnepségén a Számítógéptörténeti Múzeumban , 2007. december 10-én [1] Archiválva 2008. december 11-én, a Wayback Machine -nél [2] Archiválva : 2017. október 3., a Wayback Machine -nél . [3] .
  2. ↑ p=43 "Bill Gates személyes húsvéti tojásai 8 bites BASIC-ben - pagetable.com" . pagetable.com . Letöltve: 2018. augusztus 8 . 
  3. ^ "Billentyűzet és a képernyőszerkesztő" . 1985. július. 
  4. ^ "Bájt 1983. július" . 
  5. ↑ Leemon, Sheldon (1987). A Commodore 64 és 64C feltérképezése . KISZÁMÍT! Publikációk. p. 37. ISBN  9780874550825 . Letöltve: 2018. március 25 . 
  6. ↑ Cowper, Ottis R. (1986). A Commodore feltérképezése 128 . KISZÁMÍT! Publikációk. p. 66 . ISBN  9780874550603 . 
  7. ^ "A Commodore 64 feltérképezése" . 
  8. ↑ Leemon, Sheldon (1987). A Commodore 64 és 64C feltérképezése . KISZÁMÍT! Publikációk. p. 209. ISBN  9780874550825 . Letöltve: 2018. március 25 . 
  9. ↑ Leemon, Sheldon (1987). A Commodore 64 és 64C feltérképezése . KISZÁMÍT! Publikációk. p. 71. ISBN  9780874550825 . Letöltve: 2018. március 25 . 
  10. ↑ Leemon, Sheldon (1987). A Commodore 64 és 64C feltérképezése . KISZÁMÍT! Publikációk. p. 231. ISBN  9780874550825 . Letöltve: 2018. március 25 . 
  11. ^ "Atari BASIC és PET Microsoft BASIC. ALAPVETŐ összehasonlítás.” . 
  12. ↑ Scrimshaw, N.B. (2013. november 11.). Bevezetés a Commodore 64-be: Kalandok a programozásban . ISBN  9781489967879 . 
  13. ↑ a b http://www.zimmers.net/anonftp/pub/cbm/firmware/README.txt
  14. ^ "Mike Naberezny – Commodore LCD firmware" . mikenaberezny.com . Letöltve: 2018. augusztus 8 . 
BASIC 2.0
  • Angerhausen et al. (1983). The Anatomy of the Commodore 64 (a teljes hivatkozást lásd a C64 cikkben).
ALAP 3.5
  • Gerrard, Peter; Bergin, Kevin (1985). A COMMODORE 16 ROM teljes szétszerelése . Gerald Duckworth & Co. Ltd. ISBN  0-7156-2004-5 .
BASIC 7.0
  • Jarvis, Dennis; Springer, Jim D. (1987). BASIC 7.0 belsők . Grand Rapids, Michigan: Abacus Software, Inc. ISBN  0-916439-71-2 .
ALAP 10.0

Külső linkek

  • Ez a munka a " Commodore BASIC " származékos fordítását tartalmazza az angol Wikipédiából, amelyet kiadói adnak ki a GNU Free Documentation License és a Creative Commons Attribution-ShareAlike 3.0 Unported License alatt .
Beszerezve: « https://es.wikipedia.org/w/index.php?title=Commodore_BASIC&oldid=146673495 »