Assembly Cursus 3

 CAVorige keer hebben we een korte inleiding gehad op de hardware-laag van de Computer. We grijpen heel even kort terug naar Deel 1, hoe zat het ook alweer? Nu we de basis behandeld hebben van de binnenste werking van de Commodore, ga ik verder met het beschrijven van de registers. We hebben er zes te gaan in dit deel.

CursusAssembly Deel1 hdr

CAComputer: Commodore 64
Datum: 2011
Type: Programmeertaal
Door: Addy van Ladesteijn

CADe Assembler
Op dit punt heb je als het goed is een aardig idee wat registers zijn en welke de Commodore 64 kent. Vorige keer hebben we ze allemaal behandeld en tevens de daarbij behorende assembly commando’s genoemd. Tot zover de theorie.

Om de werking van deze commando’s (ook wel OPCODES genoemd) te kunnen zien, moeten we nu echt programmaregels gaan invoeren. Om programma’s in Assembly te schrijven hebben we een Assembler nodig. Er zijn er een aantal, maar wij gebruiken de Merlin64 Assembler. In de archieven van Arnold is deze terug te vinden via de link: arnold.c64.org/pub/uNls/c64apps/ compiler/Merlin_Assembler.zip

In deel drie zullen we de Merlin Assembler zelf behandelen, een basis die je zult moeten beheersen voor het verdere verloop van de cursus. Maar ook deze magie zal de jouwe kunnen zijn met een beetje oefenen en geduld…

Merlin is een erg fijne Assembler voor de Commodore 64. Het werkt alleen met een diskdrive en niet met een tapedrive. We zullen de Assembler beetje bij beetje behandelen, omdat het anders meer een manual gaat lijken. De commando’s die we het hardst nodig hebben behandelen we het eerste.

Om Merlin64 te starten laadt je de Assembler via: LOAD “MERLIN*”,8

Na het laden start je Merlin64 via het RUN commando. Het kan even duren. Als de Assembler gestart is, sta je automatisch in de zogenaamde “Executive Mode”. Deze herken je aan het “%” teken en betekent dat je onderstaand scherm ziet:MerlinHet is een goed idee om een eigen werkdiskette te hebben voor al je experimenten, dus gaan we deze eerst maken. Doe een lege diskette in de drive en kies “X”. Je zult een nieuwe prompt zien: “%Command:”. Kies hier een “I” en na het drukken op ENTER zal de diskette direct snel geformatteerd worden. Met het commando “C” kun je de inhoud van een diskette opvragen.

Het invoeren van een nieuw programma
Voor nu hoeven we niets meer te doen in de “Executive Mode” dus kiezen we “E” waarmee we in de Editor komen (herkenbaar aan de “:”) , de prompt verandert in “Editor:”. We zijn nu in de “Command Mode” gekomen. Om nu daadwerkelijk programma’s te kunnen schrijven kiezen we “A” (Add).

Anders dan in BASIC, heeft Merlin64 vier velden, net zoals de meeste Assemblers: LABEL, OPCODE, OPERAND, COMMENT. Met elke druk op de SPATIEBALK spring je naar het volgende veld, met ENTER ga je naar de volgende regel. De OPCODE en OPERAND velden zijn de belangrijkste. Als we sprongen gaan maken in onze programma’s zal het LABEL veld onmisbaar blijken. Om te beginnen, gaan we onderstaand regels invoeren met de OPCODE en OPERAND velden:

LN# LABEL OPCODE OPERAND COMMENT
1           JSR     $E544
2           RTS

Stap 1: Kies (als dit nog niet gedaan is) de “A” om regels in te kunnen voeren

Stap 2: Druk op de SPATIEBALK om het LABEL veld leeg te laten en naar het OPCODE veld te springen. Vul hier “JSR” in.

Stap 3: Druk op de SPATIEBALK om naar het OPERAND veld te springen en vul hier “$E544” in. Op dit adres staat de clear-­‐screen instructie.

Stap 4: Druk op ENTER om naar de volgende regel (2) te gaan.

Stap 5: Druk op de SPATIEBALK om naar het OPCODE veld te gaan en vul daar “RTS” in.

Stap 6: Druk tweemaal op ENTER. De eerste maal om naar de volgende regel te springen en de tweede maal om een uit de “Add Mode” te gaan en terug in de “Command Mode” te komen.

Gefeliciteerd! Je hebt je eerste Assembly programma geschreven. Deze staat ingevoerd in de editor maar om het uit te kunnen voeren moet je het assembleren. Dit doe je met behulp van het commando “ASM” en op ENTER te drukken. Er zal een vraag op het scherm komen “Update source (Y/N)?”, welke je met “N” mag beantwoorden. Het resultaat zal gelijk moeten zijn aan de schermafdruk hiernaast -­‐ en dat is goed. Nog een mijlpaal, want je hebt zojuist je eerste, zelfgemaakte programma, geassembleerd. Een belangrijk gegeven is dat dit programma op geheugenplaats $8000 begint, zoals het scherm laat zien. Hier staat dus de zogenaamde objectcode (geassembleerd programma) staat. De decimale waarde van $8000 is 32768. Deze waarde hebben we nodig om ons programma vanuit BASIC te kunnen starten met het commando: SYS 32768.

Het programma is gemaakt, geassembleerd en klaar voor opslag. Net als BASIC zullen programma’s verloren gaan na het uitzeKen van de computer. Om dit programma op onze vers aangemaakte werkdiskeKe op te slaan drukken we nu eerst op “Q” om de “Command Mode” te verlaten en terug te keren in de “Executive Mode”. Tik bij de % prompt nu de “S” om het programma op te slaan. Als het goed is zit je werkdiskette in de drive (mooi moment om dit even te checken). Geef als naam “clear” op, want dat is precies wat het programma zal doen als we het draaien -­‐ het scherm schoonmaken. Je ziet “Saving clear.s” staan en na het opslaan zal dit bestand op de diskette bijgeschreven zijn. Wat je nu opgeslagen hebt is niet iets wat je direct kunt starten, je hebt een zogenaamd “sourcefile” opgeslagen. In dit bestand (dat altijd eindigt op “.s”) staan de regels die je in de Editor hebt ingevoerd. De geassembleerde code (objectcode) is niet opgeslagen. Om de geassembleerde code op te slaan, druk je op de letter “O” en zal automatisch de naam van je sourcefile verschijnen, omdat je deze hiervoor opgeslagen hebt en Merlin64 ervan uitgaat dat je hiervan de objectcode zal willen opslaan.

Je hebt nu dus je source­‐ en objectcode opgeslagen op je werkdiskette. Als je via het “C” commando de inhoud van de diskette bekijkt, vind je dus de “clear.s” en “clear.o” bestanden. In het scherm is nog wat gebeurd. Als het goed is staat in het scherm een nieuwe regel met het adres van de objectcode, direct onder het adres van de sourcecode. Altijd handig om om te weten.

Laten we uit de “Executive Mode” gaan via “Q” waarna het scherm schoongemaakt wordt en Merlin64 ons nog herinnert dat we via SYS 52000 weer terug in de Assembler kunnen komen. Toen we via het “ASM” commando ons programma assembleerde, werd dit voor ons op adres $8000 gezet, waarmee we het via SYS 32768 kunnen starten. Als alles goed gegaan is, zal het scherm schoongemaakt worden zodra je het sys commando invoert en op ENTER drukt. En zo heb je dus je eerste programma in een Assembler ingevoerd, geassembleerd, opgeslagen en vanuit BASIC gestart! Tijd voor koffie.

Het bewerken van het bronbestand
Tik na de koffie SYS 52000 om weer terug in de Assembler te komen. Als de computer in de tussentijd niet uitgezet is en er geen andere programma’s geladen zijn kun je nu via de “E” toets in de editor komen. (Is dit wel het geval, dan kun je het bronbestand vanuit de “Executive Mode” laden -­‐ hierover later meer). Vanuit het Editor menu of “Command Mode” heb je nu de beschikking over de volgende keuzes:

L Geeft een Listing vna je broncode
A Voeg regels toe op de eerstvolgende regel
I# Voeg regels toe op het opgegeven nummer #
D# Verwijder regel nummer #
E# Bewerk regel nummer #
PORT# Selekteert de printer als output poort #
PRTR# Stuurt de listing naar printer met als output poort #
F Zoek naar een stuk tekst in de listing
C Verander tekst
M Verplaats regels broncode
R Verplaats regels in een bereik naar een andere selectie
NEW Verwijderd de brondcode uit het geheugen

L(ist)
Dit commando geeW de listing van het bronbestand weer. Als je later langere programma’s gaat schrijven is het handig als je een listing kunt onderbreken (of je moet razend snel leren lezen). Als je op de SPATIEBALK drukt tijdens de listing, kun je het scrollen onderbreken en vervolgens (met dezelfde toets) regel voor regel door de listing lopen. Met RETURN hervat het scrollen weer op de normale snelheid.

A(dd)
Toen we onze eerste regels in gingen voeren, drukte we hiervoor op de “A” toets. We werden automatosch op regel 1 gezet. Als je broncode in het geheugen staat, brengt deze toets na naar de eerstvolgende beschikbare vrije regel (in het geval van het “clear” programma dus regel 3).

I(nsert)
Dit commando gebruiken we om een regel tussen te voegen. Met twee regels in het geheugen kunnen we via het commando “I1” een regel tussenvoegen. Voeg bijvoorbeeld eens “ORG $C000” toe. Druk daarna tweemaal op RETURN om terug op de prompt te komen en met “L” zou de listing er dan als volgt uit moeten zien:
1 ORG $C000
2 JSR $E544
3 RTS

De ORG instructie wordt zogenaamde “Pseudo code” genoemd. Dit betekent dat deze opdracht niet geassembleerd wordt (d.m.v. ASM), maar het vertelt de assembler waar je programma moet beginnen. Doe je dit niet, dan zet Merlin64 je programma standaard op $8000. Let er wel op dat de ORG instructie de eerste regel van je programma is! Naarmate je meer gaat programmeren zul je merken dat je de I(nsert) functie erg vaak zult gebruiken.

D(elete)#
Dit is een gemakkelijk commando om te gebruiken. Je voert een “D” in, direct gevolgd door het regelnummer dat je wilt verwijderen en drukt op RETURN. “D1” verwijdert dus de eerste regel. Je kunt ook meerdere regels tegelijk verwijderen. “D1,2” verwijdert regel 1 tot en met regel 2. Hiermee verwijder je dus een bereik.

E(dit)
Om een regel te bewerken gebruik je het “E” commando gevolgd door het betreffende regelnummer. Wil je bijvoorbeeld de eerste regel bewerken, voer je “E1” in gevolgd door RETURN. Druk nu op de SPATIEBALK om naar de instructie te springen en de cursustoetsen om één karakter te verspringen. Met RETURN kom je terug in de “Command Mode”. In Edit mode heb je een aantal CTRL commando’s ter beschikking die de moeite waard zijn om te leren:

CTRL + I Voeg één karakter in CTRL+D Verwijder één karakter
CTRL + D Verwijder één karakter
CTRL + F Zoek een karakter
CTRL + O Lijkt op CTRL + I maar deze voegt een control karakter in
CTRL + P Zet een regel met sterretjes op het scherm. Druk je eerst op de spatiebalk dan krijg je sterretjes aan elke kant van de regel
CTRL + B Springt naar het begin van een regel
CTRL + N Springt naar het begin van een regel
CTRL + R Herstelt de huidige regel naar zijn originele staat
CTRL + A Schoont de huidige regel vanaf de cursor naar rechts
STOP/RUN Verlaat EDIT MODE zonder de regel te veranderen

PORT# / PRTR#
Als je een printer aangesloten hebt, kun je de uitvoer van je programma niet naar het scherm maar naar de printer sturen met het PORT commando of de listing afdrukken via het PRTR commando.

F(ind)
Als je een uitgebreid programma geschreven hebt, is het vaak handig om bepaalde zoekopdrachten uit te voeren. Met bijvoorbeeld F”JSR” krijg je alle regels te zien van het programma waarin het JSR commando voorkomt. Met F5,9″JSR” worden alle regels tussen 5 en 9 getoond waarin het JSR commando staat.

C(hange)
Dit is de Assembleer-­versie van de Zoek‐en‐Vervang opdracht. Stel je wilt alle JMP commando’s van je programma vervangen door JSR commando’s, dan kun je dit doen met het commando C”JMP”JSR”. Let erop dat je slechts gebruik maakt van drie (!) aanhalingstekens. Nadat je op RETURN gedrukt hebt, zal Merlin64 je vragen of je alle (A) of sommige (S) veranderingen wil doorvoeren. Bij de laatste optie zul je elke aanpassing afzonderlijk moeten goedkeuren.

COPY
Het zal in de toekomst voorkomen dat je bepaalde regels van je programma weer wilt gebruiken. Om te voorkomen dat je deze regels opnieuw in moet tikken, kun je het COPY commando gebruiken. Met COPY 1 TO 2 zal de eerste regel voor de tweede gekopieerd worden. Als de regel waarnaar je kopieert reeds bestaat, zal deze een regel zakken en wordt de gekopieerde regel tussengevoegd. Omgekeerd kan natuurlijk ook:

COPY 3 TO 1 zal ervoor zorgen dat regel 3 naar regel 1 gekopieerd wordt. (Waardoor regel drie zal veranderen in regel 4 vanwege de ingevoegde regel op 1). Dit commando werkt echter ook met een opgegeven bereik. COPY 10,20 TO 33 zal ervoor zorgen dat de regels van 10 t/m 20 gekopieerd worden vanaf regel 33.

MOVE
Het broertje van COPY is MOVE, met het verschil dat dit commando de regels daadwerkelijk verplaatst en niet kopieert. De werking van het MOVE commando is verder identiek aan dat van COPY. Met MOVE 5 TO 3 zal regel 5 verplaatst worden naar de derde positie, waardoor regels vier en hoger een regel naar beneden zakken.

R(eplace)#
Het replace commando roept de opgegeven regel op en zet je vervolgens in de insertmodus (gelijk aan CTRL+I) zodat je de regel kunt overschrijven.

NEW
Wist het huide bronbestand. Let op: De geassembleerde code blijven bestaan in het geheugen.

Tenslotte zijn er nog wat algemeen geldende regels. Zoals bijvoorbeeld de regel dat alle commando’s in hoofdletters geschreven moeten worden. Met behulp van de F7 toets is het mogelijk om te schakelen tussen hoofdletters en kleine letters. Maar een nog niet genoemd belangrijk commando is het omrekenen van decimale naar hexadecimale nummers (en vice versa) vanuit de “Command Mode”.

Omrekenen van Hexadecimaal naar Decimaal doe je door het hexadecimale getal op de “:” prompt in te Fkken en op RETURN te drukken.
:$C000 <RETURN>
49152 = -16384

Je kunt een programma op $C000 dus starten met SYS49152 of SYS16384. Om van Decimaal naar Hexadecimaal om te rekenen doe je het omgekeerde:
:1234 <RETURN>
$04D2

Het is verstandig om veel met bovenstaande commando’s te experimenteren, want je zult ze vaak nodig hebben tijdens het programmeren! Zeker als we de volgende keer verder gaan met deel 4 van deze cursus!