Az előző blog bejegyzésemben említettem, hogy akár PC-n is lehetséges régi számítógépeket emulálni, így ki tudjuk próbálni vagy akár programozni ezeket a régi gépeket úgy is, ha a valóságban nem rendelkezünk ilyenekkel. A mostani írás arról szólna, hogy én milyen eszközöket használok a program íráshoz, teszteléshez, ha mondjuk C64-re szeretnék valami kis programot készíteni.

Az elején szeretném tisztázni, hogy kimondottan assembly nyelven történő programozásról lesz szó. Főleg azért, mert a hardverközeli dolgokat célszerűbb ezen a nyelven programozni, és szerintem ez az a terület ami igazán érdekes lehet még mai szemmel is a régi számítógépekben. A C64 BASIC-ben is sok mindent meg lehet csinálni a PEEK és POKE utasításokkal, amelyekkel direkt hozzá lehet férni a gép memóriájához és a periféria áramkörök regisztereihez, csak nem sok értelme van ennek a fából vaskarika megoldásnak. Az assembly sokkal alkalmasabb ilyesmire és nem utolsósorban gyorsabb és kisebb méretű programokat lehet így készíteni, ami lényeges szempont egy olyan számítógépen, amelynek kevesebb memóriája van, mint egy átlag email mérete. Egyébként a C64 BASIC programozáshoz van egy nagyszerű integrált fejlesztő rendszer PC-n, de azt majd talán máskor mutatom be.

Ezt az írást leginkább figyelemfelkeltőnek, kedvcsinálónak szánom azoknak, akik valamilyen programozási ismeretekkel már rendelkeznek PC-n. Mondjuk készítettek Windows programokat Visual BASIC-ben, vagy írtak Excel makrókat, esetleg programoztak már Arduino-t. Kezdjük ott, hogy assembly programot nagyon egyszerű írni, mert csak egy szövegszerkesztő kell hozzá. Akár a Windows Notepad is alkalmas erre, de ettől azért van jobb választás. Én személy szerint a Notepad++ progit használom. Ennek nagy előnye, hogy sokkal áttekinthetőbb módon lehet vele megjeleníteni a forrás kódot, illetve a program írást is segíti azzal, hogy automatikusan ki tudja egészíteni az elkezdett szavakat, így nem kell mindig mindent végig gépelni. 

Az assembly sajnos nem teljesen univerzális nyelv. Vannak ugyan hasonlóságok, de ahány gyártó, annyi féle nyelvjárás létezik. A C64-ben a MOS 6510 típusú CPU ketyeg, így ezt a nyelvjárást kell elsajátítani. A 6510 utasításkészlete nagyon egyszerű, ami az assembly programozással való első ismerkedés során előnyös, de ez az egyszerűség bizonyos nehézséget is jelent a későbbiekben, mert többet kell dolgozni egy adott feladat megoldásához, mint egy bővebb utasításkészlettel rendelkező CPU esetében.

Így néz ki egy Notepad-ban megnyitott, 6510-re íródott assembly program részlete:

 Így pedig a Notepad++-ban:

Azt hiszem, hogy jól látszik a különbség, a használatot segítő sok ügyes funkcióról nem is beszélve.

Miután elkészültünk a program írásával, amit forráskódnak nevezünk, kell valami, ami az assembly nyelven írt programot lefordítja gépi kódra, amit object code-nak szokás hívni. A gépi kód az a bináris számsorozat, amit a számítógép processzora közvetlenül "megért". A gépi kódra történő fordítást az úgynevezett compiler-ek, magyarul fordítóprogramok végzik. A fordítóprogramok processzor specifikus kódot állítanak elő, ami azt jelenti, hogy csak egy adott processzor típuson fog működni a kód, ezért minden processzor típushoz létezik olyan fordítóprogram, ami képes az adott processzor által értelmezhető kódra lefordítani az assembly nyelven írt programot. Léteznek olyan fordítók is, amelyek többnyelvűek, több féle processzort is ismernek, így egy fordítót használhatunk különböző processzorokra írt programok fordításához.

Én a Telemark Assembler-t vagy röviden a TASM-ot használom, ami szintén egy több nyelvű fordítóprogram. Ezeket a processzorokat vagy inkább processzor családokat ismeri: 

6502
6800/6801/68HC11
6805
8048
8051
8080/8085, Z80
TMS32010, TMS320C25
TMS7000
8096/80196

A 6510 is a 6502 család tagja, így ehhez a procihoz is használható a TASM. A 6502/6510 CPU-hoz nagyon sokféle fordítóprogram létezik, mivel ez egy elég népszerű processzor volt annak idején, de a mai napig gyártják még az egyik újabb kori reinkarnációját. Én tudatosan választottam a bőséges lehetőségek közül a TASM-ot, mert terveimben szerepel, hogy valamikor szeretnék majd multi platform szoftvereket írni, vagyis ugyanazt a programot több különböző processzorra is szeretném lefordítani. Persze ez nem azt jelenti, hogy mindenféle változtatás nélkül ugyanaz a forráskód lefordítható különböző procik gépi kódjára, de számomra egyszerűbbnek látszik, hogy ugyanazt a compiler-t tudom majd használni és nem kell megtanulni minden egyes fordító kismillió opcióját, hanem elég eggyel megismerkedni.

A fordítóprogramok használata nem bonyolult, habár a régebbi darabok parancssoros alkalmazások, így aki csak a Windows ablakokkal találkozott korábban, annak kissé idegen lehet a használatuk. Kb. így néz ki egy parancssorból indított fordítás a TASM-al: tasm -65 -b test01.asm test01.prg 

Ha minden jól megy és nincs semmi hiba az assembly programban, létrejön egy úgynevezett lista fájl és maga a gépi kódot tartalmazó program fájl. A lista fájlban soronként egymás mellé írva látszik a gépi kód és az assembly nyelvű megfelelője. Valahogy így néz ki:

Evvel igazából túl sok dolga nincs az embernek, de ha a fordításkor valami hibába ütközik a fordító, akkor a hibára utaló megjegyzések ebben a listában olvashatók, illetve itt már látszik az is, hogy konkrétan milyen memória címeken fog elhelyezkedni a gépi kódú program.

A lényegesebb maga a gépi kódú programot tartalmazó úgynevezett bináris fájl. Ezt már alkalmas arra, hogy egy valódi számítógépen vagy jelen esetben majd az emulátoron futtassuk. Egy szöveg nézegetővel megjelenítve így néz ki a tartalma:

Ez már határozottan nem embernek való olvasmány, de nem is az a lényege, hogy mi emberek megértsük. Elég ha a processzor "megérti".

Mondjuk, hogy eljutottunk idáig és van egy lefordított gépi kódú programunk. Mit lehet ezzel csinálni? Több dolgot is, de amit a következőkben szeretnék bemutatni, az egy úgynevezett debugger. A debugger egy olyan alkalmazás, ami a programhibák (bug-ok) megtalálását teszi egyszerűbbé. A legfontosabb tulajdonsága, hogy a debugger-ben elindítva a programunkat, akár soronként, lépésenként is végre tudjuk azt hajtatni. Közben minden olyan információt megjelenít a debugger, ami alapján tudjuk ellenőrizni, hogy a programunk valóban azt csinálja amit szeretnénk. Töréspontokat tudunk elhelyezni a programnak azokra a helyeire, ahol azt szeretnénk, hogy álljon meg a végrehajtás, hogy tudjuk ellenőrizni a program működését. Ennél még sokkal több lehetőséget is biztosítanak ezek a nagyon hasznos alkalmazások, de bevezetőnek ennyi is elég.

Ha PC-n szeretnénk C64-re írt programokat debuggolni, akkor az egyik legjobb választás az egyszerűen csak C64 Debugger-nek nevezett hiper-szuper alkalmazás. Ez tulajdonképpen tartalmazza a VICE nevű C64 emulátort, amit kiegészítettek a debuggolást megkönnyítő funkciókkal. A futtatható programmal együtt letöltésre kerül egy elég jó manual is, amiből el lehet sajátítani a kezelését, így csak néhány alapvető dolgot említek meg a használatával kapcsolatban. A progi elindítása után ez a kép fogadja az embert:

Nem állítom, hogy első pillanatra nem kaotikus amit az ember lát, de hamar el lehet igazodni rajta. A főbb részek:

A jobb oldalon, felül lévő kék terület maga a C64 emulátor képe, amin indítás után a C64 kezdő képernyője látható, felette a CPU regiszterek tartalma van megjelenítve.

Bal oldalt a disassembler által visszafordított programlista látszik, ahol az aktuálisan végrehajtás alatt lévő utasítást megjelöli a program. A disassembler pont a fordítottját csinálja mint a compiler. Gépi kódból tud visszafordítani assembly nyelvre, így az ember által jobban érthető módon jelenik meg a program lista. Amíg nem töltjük be és indítjuk el a saját programunkat, addig a C64, kis túlzással operációs rendszernek nevezett alap programja fut. Ez végzi a képen látható karakterek megjelenítést, a kurzor villogtatását, a billentyűleütések figyelését és még egy csomó dolgot.

A hexadecimális számsorokat tartalmazó, középen alul látható terület az úgynevezett memória dump. Itt egyszerűen csak azt látjuk, hogy a memória egy adott címén milyen értékek vannak aktuálisan. Ami egy jópofa dolog, hogy a memória tartalmát innét közvetlenül át is tudjuk írni és ezek a változtatások valós időben érvényre is jutnak. Ez sokszor hasznos, ha ki szeretnénk próbálni valamit vagy bizonyos változók értékét közvetlenül szeretnénk manipulálni. A hexadecimális értékeket tartalmazó táblázat mellett ugyan ennek a memória területnek  ASCII kódokkal reprezentált kiíratása, illetve még jobbra, bitmap képként történő megjelenítése látható.

Az emulátor képe mellett a C64 mind a 64 kbyte memóriájának egyfajta grafikus reprezentációja látszik. Ennek tartalma egyébként nagyítható is. Túl sok hasznát eddig nem vettem, de lehetséges, hogy ez csak az én fogyatékosságom.

A lefordított programot a CTRL+O billentyű kombináció lenyomásával lehet a legegyszerűbben betölteni és elindítani a debuggerben. A szokásos Windows fájl kiválasztó ablakban ki kell választani a fájlt és a "Megnyitás" gomb megnyomását követően rövidesen elindul a művünk futtatása:

További hasznos billentyűkombinációk:

A virtuális C64 alaphelyzetbe állítása: CTRL+R
A korábban már megnyitott fájl újra töltése és indítása: CTRL+L
Lépésenkénti végrehajtás: F10
Futtatás: F11
Töréspontokat a bal oldalon látható cím oszlop megfelelő sorára kattintva lehet elhelyezni illetve törölni.

A program még nagyon sok egyéb lehetőséget rejt magában, de ezek részletes ismertetésére nem vállalkozom. Persze ha lenne rá igény, akkor minden lehetséges. :-)

Röviden ennyit szerettem volna megmutatni ízelítőül. Ilyen rövidre fogva a mondandómat nyilván nem tudtam kitérni minden részletre, de remélem, hogy kedvcsinálónak ez is elég lesz.