Hlavní navigace

Cross assemblery a cross překladače pro platformu osmibitových domácích mikropočítačů Atari

11. 5. 2021
Doba čtení: 39 minut

Sdílet

 Autor: Michal Tauchman
Dnes se zaměříme na popis cross překladačů a cross assemblerů. Zmíníme se například o projektu Mad-Assembler, který je používán dodnes, podobně jako cross překladač programovacího jazyka C.

Obsah

1. Cross assemblery a cross překladače pro platformu osmibitových domácích mikropočítačů Atari

2. Vznik moderních assemblerů má kořeny v padesátých letech

3. První makroassemblery

4. Svět cross assemblerů

5. Cross assemblery pro mikroprocesor 6502,

6. Jednoprůchodové versus víceprůchodové assemblery

7. Specifika počítačů Atari z hlediska cross assemblerů

8. Cross assembler ATasm

9. Makra aneb první krok k vysokoúrovňovým jazykům

10. Cross assembler ca65

11. Cross assembler xa65

12. To nejlepší na konec – Mad-Assembler (MADS)

13. Svět cross překladačů

14. cc65

15. Atalan

16. Doplnění: makro assemblery pro osobní mikropočítače s mikroprocesorem Motorola 68000

17. Příloha 1: instalace cross assembleru ATasm

18. Příloha 2: instalace cross assembleru xa (xa65)

19. Příloha 3: instalace MAD Assembleru na Linuxu

20. Odkazy na Internetu

1. Cross assemblery a cross překladače pro platformu osmibitových domácích mikropočítačů Atari

V článcích o vývojových prostředích a nástrojích určených pro osmibitové domácí mikropočítače Atari [1] [2] pochopitelně nemůžeme zapomenout ani na takzvané cross compilery a cross assemblery (viz poznámka o českém překladu tohoto názvu umístěná na konci této kapitoly). Tyto typy vývojových nástrojů jsou velmi často používané i dnes, zejména v oblasti mikrořadičů, digitálních signálových procesorů nebo mobilních telefonů (viz například projekt Scratchbox). Ovšem tato technologie se ve skutečnosti používala již na samotném začátku osmibitové éry (a to nejenom na osmibitových domácích mikropočítačích, ale i na počítačích určených pro průmyslová použití, což je zcela odlišná kategorie strojů, které ovšem mnohdy používaly totožné typy mikroprocesorů).

Obrázek 1: Platformovka Cohen's Towers ve variantě pro osmibitové mikropočítače Atari.

Například vývoj her pro herní konzoli Atari 2600 (Atari Video Computer System neboli Atari VCS) byl ve skutečnosti prováděn na minipočítači (a podle pamětníků se jednalo o poměrně propracované vývojové nástroje – samozřejmě s ohledem na dobové možnosti). Ovšem i později některé firmy vyvíjely profesionální software určený pro osmibitová Atari i pro další osmibitové mikropočítače na výkonnějších strojích, kde se prováděl i překlad, slinkování a příprava výsledného binárního obrazu pro cartridge či dokonce přímo příprava disket (nebo jejich binárních obrazů). Poněkud předběhněme: přesně tento princip je používán i v moderních cross assemblerech a cross překladačích pro osmibitová Atari, které budou zmíněny v navazujících kapitolách.

Obrázek 2: Obrazovka ze hry Mr.Do! po konverzi na osmibitové domácí mikropočítače. Původně se jednalo o hru určenou pro herní automaty, později vyšla i pro prakticky všechny typy osmibitových mikropočítačů a to mj. i díky možnosti cross překladu pro různé platformy.

Poznámka: již minule jsme si řekli, že existuje i český termín křížový překladač, ale musím se přiznat, že mi připadá jako výsledek otrockého překladu a navíc se slovo „cross“ přeložilo ve špatném kontextu.

2. Vznik moderních assemblerů má kořeny v padesátých letech

Vývoj assemblerů je poměrně úzce spjatý s prvními počítači (tehdy většinou mainframy), které používaly pro uložení programů nějakou formu zapisovatelné či dokonce přepisovatelné paměti [3]. Dobrým příkladem může být počítač EDSAC neboli Electronic Delay Storage Automatic Calculator. Pro tento počítač byl v roce 1949, tedy před sedmdesáti lety, vytvořen velmi jednoduchý assembler, v němž byly mnemotechnické zkratky instrukcí zkráceny na jediný znak. Tento koncept byl později rozšířen, takže se v pozdějších assemblerech setkáme s mnemotechnickými zkratkami instrukcí se dvěma, třemi, čtyřmi či s proměnným počtem znaků. Ovšem poměrně často se i u pozdějších assemblerů setkáme s třípísmennými zkratkami; například u assemblerů pro mikroprocesory Intel 8080, Intel 8086, MOS 6502 atd. (a tedy i u cross assemblerů zmíněných v dnešním článku).

Obrázek 3: Telefonní volič pocházející zhruba z doby vzniku hry OXO.

Poznámka: s počítačem EDSAC zmíněným v předchozím odstavci jsme se již na stránkách Rootu kdysi setkali. Právě na tomto počítači totiž vznikla první skutečná počítačová hra. V tomto roce 1952 totiž dopsal Alexander S. Douglas (tehdy student na univerzitě v Cambridge) svoji disertační práci na téma problematiky interakce člověka s počítačem (což tehdy pochopitelně byla dosti žhavá novinka). V rámci své práce naprogramoval Douglas na počítači EDSAC jednu z prvních skutečných počítačových her pojmenovanou OXO. Jednalo se o zjednodušenou variantu piškvorků hranou na herní ploše mající rozměry 3×3 políčka. Tato hra je v anglosaském světě známá právě pod názvem OXO (název je samozřejmě složen z tvarů symbolů používaných ve hře), popř. Tic-Tac-Toe nebo Noughts and Crosses. Zajímavé bylo ovládání této hry, protože se jako ovladač využíval otočný telefonní volič, který si pravděpodobně pamatujete z relativně nedávné éry používání telefonů (a dálnopisů) s pulsní volbou.

Obrázek 4: Assembler na mikropočítači Commodore C64 je již ukázkou moderně pojatého assembleru. Povšimněte si třípísmenných mnemotechnických jmen instrukcí, o nichž jsme se zmínili výše.

Ovšem vraťme se zpátky k prvním nástrojům, které dnes nazýváme assemblery. V roce 1955 vznikl pro počítače řady IBM 650 systém SOAP neboli celým jménem Symbolic Optimal Assembly Program (ať již slovo „optimal“ mělo znamenat cokoli). Autorem tohoto systému, kde se již objevuje slovo assembler, byl Stan Poley. Právě v této době, tj. zhruba v polovině padesátých let minulého století, se assemblery rozšířily i na prakticky všechny ostatní typy mainframů vyráběných osmi nejvýznamnějšími společnostmi v této oblasti (kterým se přezdívalo „IBM a sedm trpaslíků“). Mezi tyto společnosti patřily firmy Borroughs, UNIVAC, NCR, Control Data Corporation (CDC), Honeywell, RCA a General Electric (GE).

Obrázek 5: Obal na kazetu se Zeus Assemblerem pro ZX Spectrum. Jedná se o klasický nativní assembler – překlad probíhal na stejném stroji, pro který byl určen samotný assembler.

Poznámka: IBM 650, který začal být nabízen v roce 1954, se stal velmi populárním počítačem a používal se i ve školství. Tento počítač používal dekadický kód instrukcí i dat, což zjednodušovalo práci na nízké úrovni (assembler, monitor atd.) a vybaven byl pamětí založenou na magnetickém bubnu s kapacitou 1000 slov, 2000 slov či při použití nejvyšší konfigurace 4000 slov.

Obrázek 6: Vývojové prostředí Zeus Assembleru (vývojovými prostředky určenými pro ZX Spectrum se budeme zabývat v samostatném článku, který na tento miniseriál navazuje).

Původní assemblery prováděly pouze základní činnost – překlad mnemotechnických kódů instrukcí do strojového kódu. Takový překlad bylo možné provést v jednom průchodu, což mj. znamenalo, že zdrojový kód mohl být uložen na děrných štítcích nebo děrných páskách a výsledek opět mohl být zaznamenán na stejná datová média. Spotřeba paměti pro překlad (v angličtině se používá assembly neboli sestavení) byla v tomto případě minimální a nebyla ani závislá na objemu zdrojového kódu. Ovšem současně byly tyto assemblery dosti omezené, například neumožňovaly použití návěstí (label) u cílů skoků. Tento nedostatek byl odstraněn u další generace assemblerů podporujících takzvané symbolické adresy. Proto se někdy assemblery nazývaly jazyk symbolických adres – JSA.

Poznámka: ve skutečnosti je možné i při jednom průchodu vytvořit binární tvar programu, který však v některých případech nebude přímo spustitelný, protože vyžaduje linker, který mj. doplní chybějící cílové adresy skoků, volaných subrutin atd.

Obrázek 7: Jak se programovalo v assembleru si můžete vyzkoušet na stránce http://6502asm.com. Zde je implementován assembler i emulátor počítače založeného na osmibitovém mikroprocesoru MOS 6502.

3. První makroassemblery

Programům zmíněným ve druhé kapitole, jejichž možnosti se postupně vylepšovaly (například do nich přibyla podpora textových maker, řízení víceprůchodového překladu, překlad využívající podmínky pro výběr větví kódu, vytváření výstupních sestav s překládanými symboly, později i skutečné linkování s knihovnami atd.), se začalo obecně říkat assemblery a jazyku pro symbolický zápis programů pak jazyk symbolických instrukcí či jazyk symbolických adres – assembly language (někdy též zkráceně nazývaný assembler, takže toto slovo má vlastně dodnes oba dva významy). Jednalo se o svým způsobem převratnou myšlenku: sám počítač byl použit pro tvorbu programů, čímž odpadla namáhavá práce s tužkou a papírem.

Obrázek 8: Úvodní obrazovka Atari Macro Assembleru. Tímto nástrojem jsme se již v tomto seriálu zabývali, a to konkrétně v tomto článku.

Zapomenout v tomto kontextu nesmíme ani na počítač GE-635 a pro něj vyvinutý makroassembler GEMAP, protože právě s využitím tohoto prostředku vznikla první verze UNIXu. Vývoj tohoto operačního systému začal na PDP-7, ovšem hardwarové možnosti tohoto počítače byly velmi omezené, například kapacita operační paměti dosahovala pouze 8192 osmnáctibitových slov, tj. osmnácti kilobajtů. Z tohoto důvodu byl originální UNIX (který ovšem toto jméno ještě neměl) naprogramován v assembleru počítače PDP-7, přičemž je zajímavé, že vlastní vývoj byl prováděn na jiném (výkonnějším a taktéž mnohem dražším) počítači: již zmíněném 36bitovém GE-635 s využitím makroassembleru GEMAP. Po vytvoření objektového kódu tímto assemblerem se (stále ještě na počítači GE-635) zapsalo přeložené jádro i další pomocné programy na děrnou pásku, která se následně vložila do čtecího zařízení na počítači PDP-7, odkud se systém „nabootoval“ patřičným příkazem zadaným z řídicího panelu – máme zde tedy pěkný praktický příklad použití jak cross assembleru, tak i cross překladače.

Obrázek 9: Vývojové prostředí Atari Macro Assembleru. Opět si povšimněte použití třípísmenných mnemotechnických názvů instrukcí.

4. Svět cross assemblerů

Svět cross assemblerů je poměrně rozsáhlý a má za sebou již několik desítek let vývoje. Cross assemblery se typicky používají (a s velkou pravděpodobností i budou nadále používat) pro vývoj aplikací pro čtyřbitové a osmibitové mikrořadiče, zejména v případě čipů s malým množstvím paměti RAM i ROM. Týká se to například některých řad mikrořadičů PIC a taktéž (zdá se) nesmrtelnému čipu 8051 či řadě 68HC (to je však dáno především historickými důvody, protože na trhu již existují mikrořadiče, které mají větší výkon, resp. menší spotřebu při použití stejné výrobní technologie).

PIC

Obrázek 10: Pro vývoj aplikací určených pro osmibitové mikrořadiče PIC lze použít i mnoho open source nástrojů. Na tomto screenshotu jsou zobrazena některá okna nástroje gpsim (simulátoru mikrořadičů). Už z principu činnosti těchto nástrojů se jedná o cross assemblery.

U mikrořadičů, které obsahují více RAM/ROM je ovšem stále zřetelněji vidět příklon k použití vyšších programovacích jazyků (u osmibitových čipů řady S08 a RS08 nalezneme běžné C, u šestnáctibitových čipů MSP430 je dokonce podporován Rust, a u 32bitových mikrořadičů, kde dnes jasně vede architektura ARM, konkrétně v případě malých mikrořadičů Cortex-M0 a Cortex-M0+, lze použít i mnohé další jazyky). V takovém případě se používají cross compilery; vývoj tedy neprobíhá přímo na daném čipu/mikrořadiči).

Cortex-M0

Obrázek 11: Čipy XMC4000 založené na jádru Cortex-M0.
Autor původní fotky: Davewave88.

5. Cross assemblery pro mikroprocesor 6502

V následujících kapitolách se budeme věnovat cross assemblerům, které je možné použít pro tvorbu aplikací určených pro osmibitové domácí mikropočítače Atari. Ve skutečnosti jsou však některé dále zmíněné assemblery pojaty obecněji, protože mnohé z nich je možné použít i například pro aplikace určené pro konkurenční mikropočítače Commodore C64 či C128, osobní mikropočítače Apple II (někdy dokonce i Apple IIgs), osmibitové mikropočítače vyráběné společností Acorn, osmibitové herní konzole atd. Důvod takové univerzálnosti těchto assemblerů je prostý – všechny zmíněné mikropočítače obsahují nějakou variantu osmibitového mikroprocesoru MOS 6502, popř. 8/16bitového mikroprocesoru 65816, takže assemblery mohou produkovat „kompatibilní strojový kód“. Ten pochopitelně nebude kompatibilní se všemi ostatními podpůrnými čipy, které jsou mezi zmíněnými počítači a herními konzolami naprosto rozdílné, ovšem assemblery stejně uživatele od HW daného počítače neodstiňují a ani odstiňovat nemají (tj. například kód určený pro práci s čipem ANTIC bude použitelný jen v počítačích Atari, dtto pro VIC-II a počítače Commodore).

NES

Obrázek 12: Osmibitová herní konzole Nintendo Entertainment System (NES) je přímým předchůdcem SNESu a obsahuje čip do značné míry kompatibilní s MOS 6502.

Poznámka: u dále popsaných cross assemblerů se skutečně setkáme s tím, že jsou podporovány různé cílové architektury. Typicky se jedná o kombinaci osmibitové Atari + herní konzole Atari 5200, dále je mnohdy podporována i herní konzole Atari 2600, ovšem mnohdy jsou podporovány i počítače Commodore, Acorn BBC Micro a popř. i různé herní konzole.
Acorn BBC Micro

Obrázek 13: Dobový plakát s počítačem Acorn BBC Micro, což byl předchůdce počítače Acorn Archimedes. I tento počítač byl vybaven mikroprocesorem MOS 6502.

6. Jednoprůchodové versus víceprůchodové assemblery

Assemblery (dnes v naprosté většině případů pochopitelně makroassemblery) můžeme rozdělit podle mnoha hledisek. Zejména v minulosti existovalo jedno důležité rozdělení, a to konkrétně na assemblery s jedním průchodem (one pass) a na assemblery se dvěma průchody (two pass), popř. i větším množstvím průchodů (multi pass). Interně se jednoprůchodové a víceprůchodové assemblery odlišují, protože musí být postaveny na odlišné logice práce se symboly a adresami.

Nejčastěji se setkáme s dvouprůchodovými překladači. V prvním průchodu se čte zdrojový kód a interně se vytváří tabulka symbolů a popř. i tabulka literálů (u symbolů, které prozatím nejsou definovány, se zapisuje pouze jejich název a nikoli adresa – ta se doplní později). Při této činnosti se neustále pracuje s čítačem lokací (což je vlastně obdoba PC v runtime). A u makroassemblerů se provádí další činnosti – expanze maker, rozhodnutí, která část kódu se prochází atd. Ve druhém průchodu se již za symboly doplňují jejich konkrétní adresy a s využitím tabulky operačních kódů se generuje výsledný objektový kód, popř. přímo strojový (spustitelný) kód.

Poznámka: často se setkáme s tvrzením, že první fáze provádí analýzu a druhá syntézu, což je pěkné shrnutí.

Assemblery jednoprůchodové naopak již při prvním čtení zdrojového kódu vytváří kód strojový. Ovšem u těch symbolů, u nichž není známá adresa, se opět vytváří tabulka, tentokrát adres, kde je symbol použit. Tato tabulka je při nalezení konkrétní adresy symbolu procházena a assembler se musí vrátit ve strojovém kódu zpět a doplnit tuto adresu. Interně se tedy jedná o poněkud složitější operaci, která vyžaduje použití několika triků a není tak univerzální, jako překladače dvouprůchodové.

Proč však bylo dělení na jednoprůchodové a víceprůchodové assemblery tak důležité? Souviselo to s tím, že (zejména u nativních assemblerů, tedy nikoli u cross assemblerů) bylo nutné zdrojový kód postupně načítat z úložného zařízení (typicky z diskety) a mezivýsledek překladu mnohdy taktéž ukládat na disketu a ve druhém průchodu znovu tento mezivýsledek načítat. To byla pochopitelně časově náročná operace, kterou se u jednoprůchodových assemblerů podařilo zredukovat.

7. Specifika počítačů Atari z hlediska cross assemblerů

Všechny dále zmíněné assemblery dokážou ze zdrojového kódu (ten se pro větší zmatek nazývá taktéž assembler) vytvořit takzvaný strojový kód, který může programátor nějakým způsobem dále využít, například ve formě podprogramu volaného z jiné aplikace atd. (pozor je ovšem nutné dát na to, že v případě mikroprocesoru MOS 6502 bude tento strojový kód nutné umístit na konkrétní adresu v paměti – nejde snadno relokovat). To ovšem není vše, protože cross assemblery by měly v co největší možné míře usnadnit a samozřejmě taktéž urychlit vývoj. Proto mnohé z těchto nástrojů kromě strojového kódu dokážou upravit obraz diskety (přidají do obrazu nový soubor s přeloženým objektovým kódem), popř. přímo obraz stavu počítače (viz obě poznámky pod tímto odstavcem).

Poznámka1: obrazem diskety se ve světě emulátorů osmibitových mikropočítačů Atari rozumí soubory, které skutečně obsahují binární obraz diskety. Disketová jednotka, resp. přesněji řečeno i více disketových jednotek, je totiž v emulátorech počítačů Atari představována právě těmito soubory. Jen na okraj – právě z tohoto důvodu má většina obrazů disket totožnou velikost, protože obsahují binární obraz všech sektorů, tedy i sektorů prázdných. Pokud daný assembler dokáže zapsat strojový kód na obraz diskety, bude tento kód představován novým souborem, který lze v DOSu načíst příkazem L (nebo ho jinak využít přímo v rámci dané aplikace – všechny aplikace mají přístup k zařízení D1D8 a mohou tedy přistupovat k obsahu diskety).

Obrázek 14: Namapování souborů s obrazy disket na konkrétní diskety v emulovaných disketových jednotkách.

Poznámka2: obraz stavu počítače je další typ souboru, který skutečně obsahuje stav emulovaného počítače Atari v daný časový okamžik. Do značné míry se tento soubor podobá souboru, který se vytvoří na běžném PC v případě hibernace. Emulátory počítačů Atari umožňují vytvořit stavový soubor kdykoli, například během hry před obtížnou pasáží, popř. při vývoji pro snadný návrat k danému stavu (při použití BASICu se samozřejmě zachová i zdrojový kód atd.). A vzhledem k tomu, že strojový kód vytvořený assemblerem je umístěn na konkrétní adresu (řekněme na šestou stránku paměti, tj. od adresy 1536 do adresy 1791), může assembler přímo změnit příslušnou oblast paměti ve stavovém souboru a po obnovení stavu bude tento strojový kód ihned dostupný a funkční – vlastně se jedná o hot-patch na steroidech :-)

Obrázek 15: Uložení stavu počítače lze v emulátoru skutečně provést naprosto kdykoli.

8. Cross assembler ATasm

Prvním cross assemblerem, s nímž se dnes seznámíme, je makro assembler nazvaný ATasm. Tento assembler je navržen takovým způsobem, aby byl v co největší možné míře kompatibilní s Mac/65 (viz první článek). ATasm je naprogramovaný v jazyku C a ovládá se z příkazové řádky, tak jako běžné assemblery a překladače. Mj. i z tohoto důvodu ho je možné přeložit a používat na jakékoli platformě vybavené překladačem ANSI C (dokumentace zmiňuje GNU C, ovšem použít je možné i další překladače). Důležité je, že soubory se strojovým kódem, které ATasm produkuje, lze použít několika možnými způsoby. Základem je samozřejmě klasický objektový soubor, který je dále použitelný například při uložení na určitou (předem známou) adresu v počítači. Příkladem mohou být podprogramy typicky ukládané do šesté stránky paměti.

Obrázek 16: Úvodní obrazovka MAC/65 verze 1.02.

Ovšem kromě toho je možné výsledek překladu uložit na obraz diskety pod určitým jménem (strojový kód se pak zobrazí v DOSu a lze ho načíst příkazem L). Podporovány jsou dva formáty – XFD i ATR (oba podporované většinou současných emulátorů). A navíc dokáže Atasm upravit přímo stavový soubor počítače, což je asi nejrychlejší způsob, jak výsledek překladu otestovat. Jako každý moderní assembler podporuje Atasm makra a podmíněný překlad.

Obrázek 17: MAC/65 – po opuštění debuggeru příkazem Q je možné pokračovat ve vývoji, například si nechat vypsat uživatelem zapsaný kód příkazem PRINT, zde bez čísel řádků.

Příklad zdrojového textu kompatibilního s ATasmem:

        symbol .= table
        value = 10
        wsync = $D40A

        *=$600
DLI
        pha                     ; this is a test of comments
        lda #8+3*2
        sta WSYNC
        sta $d000
        pla
        rti

         .MACRO VDLI
         ldy # <%1
         ldx # >%1
         lda #$c0
         sty $0200
         stx $0201
         sta $d40e
         .ENDM

9. Makra aneb první krok k vysokoúrovňovým jazykům

Díky knihovním makrům ovšem může text zapsaný v assembleru ATasm vypadat vysokoúrovňově:

1000     .TITLE "A SAMPLE PROGRAM USING IOMAC.LIB"
1010     .OPT NO LIST
1020     .INCLUDE sysequ.m65
1030     .INCLUDE iomac.lib
1040     .OPT LIST
1050     .PAGE "   [end of equates and libraries...begin code]"
1060     .OPT NO MLIST
1070     *=  $7000   ; an arbitrary location
1080 ;
1090 SAMPLE
1100     JMP AROUND  ; skip buffers, etc.
1110 ;
1120 BUFFER *= *+256
1130 ;
1140 MESSAGE1 .BYTE +$80," This is a test of the sample program  Type your name here : "
1150     .BYTE " "
1160 M1LENGTH = *-MESSAGE1
1170 MESSAGE2 .BYTE "Hi there, "
1180 M2LENGTH = *-MESSAGE2
1190 ;
1200 ; BEGIN ACTUAL CODE
1210 ;
1220 AROUND
1230      OPEN  3,8,0,"P:"
1240      BPUT  0,MESSAGE1,M1LENGTH
1250      INPUT  0,BUFFER
1260      PRINT  0
1270      BPUT  0,MESSAGE2,M2LENGTH
1280      PRINT  0,BUFFER
1290      PRINT  3,"Also, we send it to the printer..."
1280      BPUT  3,MESSAGE2,M2LENGTH
1310      PRINT  3,BUFFER
1320      PRINT  0,"That's all folks"
1330      CLOSE  3
1340     RTS
1350     .OPT NO LIST
1360     .END
Poznámka: v tomto zdrojovém kódu vlastně není přímo použita ani jedna instrukce!

Vše je zajištěno díky knihovnímu souboru iomac.lib s mnoha užitečnými makry, například:

2310 ; MACRO:  OPEN
2320 ;
2330 ;  FORM:  OPEN ch,aux1,aux2,filespec
2340 ;
2350 ; ch is given as in the @CH macro
2360 ; aux1 and aux2 are given as in the @CV macro
2370 ; filespec is given as in the @FL macro
2380 ;
2390 ; will attempt to open the given file name on
2400 ; the given channel, using the open "modes"
2410 ; specified by aux1 and aux2
2420 ;
2430     .MACRO OPEN
2440     .IF %0<>4
2450       .ERROR "OPEN: wrong number of arguments"
2460       .ELSE
2470       .IF %4<256
2480          XIO  COPN,%1,%2,%3,%$4
2490         .ELSE
2500          XIO  COPN,%1,%2,%3,%4
2510         .ENDIF
2520       .ENDIF
2530     .ENDM
Poznámka: povšimněte si podmínek, což jsou konstrukce vyhodnocované v době překladu.

10. Cross assembler ca65

Dalším cross assemblerem, s nímž se dnes alespoň ve stručnosti seznámíme, je assembler nazvaný ca65. Jedná se o assembler, který je součástí projektu cc65, tedy překladače programovacího jazyka C pro mikroprocesory MOS 6502, 65C02 i pro šestnáctibitový procesor 65816 (který ovšem nabízí režim zpětné kompatibility s MOS 6502). Ve skutečnosti je ovšem možné ca65 použít samostatně – na cc65 závislý není (ve skutečnosti je závislost právě opačná). Opět se jedná o makro assembler, jenž je zajímavý tím, že je jednoprůchodový, na rozdíl od přece jen častějších dvouprůchodových assemblerů.

Následuje příklad rutiny naprogramované pro ca65:

Label:                          ; A label and a comment
        lda     #$20            ; A 6502 instruction plus comment
L1:     ldx     #$20            ; Same with label
L2:     .byte   "Hello world"   ; Label plus control command
        mymac   $20             ; Macro expansion
        MySym = 3*L1            ; Symbol definition
MaSym   = Label                 ; Another symbol

V režimu 65816 je k dispozici několik jmenných aliasů instrukcí, které se snaží sblížit původní jmenné konvence s novými instrukcemi, které v MOS 6502 neexistují:

CPA CMP
DEA DEC A
INA INC A
SWA XBA
TAD TCD
TAS TCS
TDA TDC
TSA TSC

Podporovány jsou i některé nedokumentované či nesmyslné instrukce, které ovšem MOS 6502 zpracovává, neboť jeho dekodér instrukcí nezachytí nesmyslné operační znaky:

ALR A:=(A and #{imm})/2
ANC A:=A and #{imm}
ARR A:=(A and #{imm})/2
AXS X:=A and X-#{imm}
DCP {adr}:={adr}-1; A-{adr}
ISC {adr}:={adr}+1; A:=A-{adr}
LAS A,X,S:={adr} and S
LAX A,X:={adr}
RLA {adr}:={adr}rol; A:=A and {adr}
RRA {adr}:={adr}ror; A:=A adc {adr}
SAX {adr}:=A and X
SLO {adr}:={adr}*2; A:=A or {adr}
SRE {adr}:={adr}/2; A:=A xor {adr}

11. Cross assembler xa65

Dalším cross assemblerem, jenž si dnes popíšeme, je nástroj nazvaný jednoduše xa, popř. xa65. Jedná se o univerzální assembler podporující všechny varianty mikroprocesorů MOS 6502 a taktéž šestnáctibitový čip 65816. Vzhledem k tomu, že se jedná o univerzální assembler, je použitelný například i pro tvorbu aplikací pro herní konzole osazené čipem 6502 atd. – na druhou stranu ovšem postrádá specializované vlastnosti, které by ocenili programátoři s cílem tvorby aplikací pro osmibitová Atari – není tedy podporován ani zápis výsledného kódu na obraz diskety, ani například přímá úprava stavového souboru.

Mezi zajímavé vlastnosti assembleru xa patří preprocesing odvozený od céčka (resp. jeho preprocesoru), podpora pro pseudoinstrukce, možnost generování objektového kódu, který je možné dále slinkovat například s výsledkem překladu céčkem a dokonce i bloková struktura, která ovlivňuje viditelnost lokálních symbolů (vhodné pro rozsáhlejší aplikace). K assembleru xa nepřímo patří i nástroj dxa, což je disassembler.

Příkazy preprocesoru podporované xa:

#include „filename“
#echo comment
#print expression
#printdef DEFINED
#define DEF text
#ifdef DEF
#else
#endif
#ifndef DEF
#if expression
#iflused label
#ifldef label

12. To nejlepší na konec – Mad-Assembler (MADS)

Nejlepším cross assemblerem pro domácí osmibitové mikropočítače Atari je MAD Assembler. Ten je naprogramován – na rozdíl od všech assemblerů zmíněných v předchozích kapitolách – v Delphi a nikoli v jazyku C. Ovšem díky tomu, že projekt Free Pascal dokáže překládat i zdrojový kód naprogramovaný v Delphi (což je rozšíření původního Object Pascalu, který vznikl z dialektu Pascalu společnosti Borland), je možné MAD Assembler přeložit a zcela bez problémů používat i na Linuxu. Způsobu překladu tohoto assembleru právě pro Linux se ostatně věnujeme ve třetím dodatku k dnešnímu článku. MAD Assembler se volá z příkazového řádku, ovšem existuje pro něj například plugin pro Eclipse, který umožňuje většinu operací provádět přímo z tohoto integrovaného vývojového prostředí.

MAD Assembler dokáže gnerovat různé formáty souborů s přeloženým strojovým kódem. Užitečný je především formát XEX, který je přímo zpracovatelný prakticky všemi současnými emulátory počítačů Atari – tvořený program je tedy možné velmi rychle spustit a otestovat.

I MAD Assembler, podobně jako ca65, podporuje některé nelegální instrukce:

ASO   RLN   LSE   RRD   SAX   LAX   DCP   ISB
ANC   ALR   ARR   ANE   ANX   SBX   LAS   SHA
SHS   SHX   SHY   NPO   CIM

Popř. instrukce specifické pro 16bitový mikroprocesor 65816:

STZ   SEP   REP   TRB   TSB   BRA   COP   MVN
MVP   PEA   PHB   PHD   PHK   PHX   PHY   PLB
PLD   PLX   PLY   RTL   STP   TCD   TCS   TDC
TSC   TXY   TYX   WAI   WDM   XBA   XCE   INA
DEA   BRL   JSL   JML

Příklad maker:

.macro instLO inst, src
    .if (.match (.left (1, {src}), #))
        inst #<(.right (.tcount ({src})-1, {src}))
    .else
        inst src
    .endif
.endmacro
 
 
 
.macro stax dst
        sta dst
        stx dst+1
.endmacro

Příklad části programu napsaného v MADsu:

.proc gr8
        ldx #$60
        lda #CLOSE
        jsr xcio
 
        lda #8+16
        sta ioaux2,x
        lda #0
        sta ioaux1,x
        mwa #devstr ioadr,x
        lda #OPEN
        jsr xcio
 
        lda SAVMSC
        ldx SAVMSC+1
        ldy #0
 
loop:
        sta grLinL,y
        clc
        adc #40
        pha
        txa
        sta grLinH,y
        adc #0
        tax
        pla
 
        iny
        cpy #192
        bne loop
 
        ldy #0
        lda #128
        ldx #0

13. Svět cross překladačů

Kromě cross assemblerů vzniklo pro domácí osmibitové mikropočítače Atari i několik cross překladačů (cross compiler). Konceptem se cross překladače neliší od cross assemblerů, protože cíl je stále stejný – umožnit vývoj aplikací na počítačích s většími možnostmi (dostupná paměť, výpočetní výkon, …), než mají cílové počítače, až výsledný strojový kód bude přenesen a spuštěn na Atari. Zatímco u cross assemblerů je důvodem pro jejich existenci zejména mnohem větší rychlost překladu (a samozřejmě možnost používat textové editory a IDE s vyšším rozlišením, než poskytuje čip Antic), u cross překladačů je mnohdy jejich existence nutná z toho důvodu, že samotný překladač je tak složitý a velký, že se nemusí vejít do operační paměti osmibitových Atari, popř. se do paměti nevejdou tabulky symbolů (symbol tables) vytvářené v čase překladu (compile time).

Dobrou ukázku rozdílu mezi možnostmi nativních překladačů a cross překladačů můžeme vidět na příkladu programovacího jazyka C. Nativní překladač jazyka C pro osmibitová Atari (tento překladač se jmenuje Deep Blue C) je nejenom relativně pomalý, ale navíc je jeho použití na počítačích Atari limitováno jak poskytovanými vlastnostmi (ne všechny konstrukce z C jsou implementovány nebo implementovány plně), tak i tím, že ve standardní znakové sadě Atari se nevyskytují znaky pro složené závorky „{“ a „}“, které se nahrazují jinými znaky. Namísto toho cross překladač C již může být plně kompatibilní s ANSI C (C89), popř. dokonce s C99 (teoreticky, protože tohoto cíle nebylo dosaženo).

Poznámka: namísto znaků „{“ a „}“ se v Deep Blue C používaly sekvence „$(“ a „$)“, takže se program typu Hello world zapisoval takto:
main()
$(
    printf("Hello World!");
$)

14. cc65

Prvním cross překladačem, s nímž se v dnešním článku seznámíme, je překladač programovacího jazyka C, který se jmenuje cc65. Ve skutečnosti se však nejedná pouze o čistý překladač céčka, ale o sadu dalších vývojářských nástrojů, mezi něž patří i výše zmíněný cross assembler ca65, dále linker ld65, disassembler da65, simulátor procesorů 6502 sim65 atd. Tento překladač je možné použít nejenom pro tvorbu aplikací pro osmibitové mikropočítače Atari, ale i pro Commodore (VIC20, C64, C128 atd.), osmibitové mikropočítače řady Apple II, herní konzoli NES, TurboGrafx-16 atd.

cc65 do určité míry odpovídá ISO standardu jazyka C (a tím pádem i původnímu ANSI standardu, dokonce je podporováno několik vlastností z C99); standard je vnucen přepínačem –standard. Existuje však několik rozdílů a nedostatků cc65, mezi něž patří neexistence datových typů float a double (a tím pádem i celá část céčka, která předepisuje konverze atd.). Dále existuje omezení funkcí – funkce nemohou vracet struktury ani unie; struktury dokonce není možné předávat hodnotou (což ale většinou nevadí, právě naopak). Kromě toho je sice možné použít modifikátor volatile, ovšem ten nemá žádný podstatný význam (což je v případě mikroprocesorů MOS 6502 a jejich možností pochopitelné).

Naopak mezi rozšíření cc65 oproti standardu patří podpora bloků psaných v assembleru, podpora pseudoproměnných A a AX (což je primární registr mikroprocesoru, tedy akumulátor, v případě AX rozšířený na šestnáct bitů přes registr X). Podporovány jsou konstanty zapsané ve dvojkové soustavě (0b101) a použít lze i počítaná goto (což je částečně převzato z GCC).

15. Atalan

Dalším cross překladačem, o němž se musíme v rámci popisu vývojových nástrojů pro osmibitová Atari zmínit, je překladač programovacího jazyka Atalan, jehož autorem je kamarád atarista Rudla Kudla. Atalan je, ostatně jak již jeho název naznačuje, jazyk určený primárně pro použití na osmibitových Atari (pro počítače vybavené MOS 6502), ve skutečnosti ovšem navíc dokáže generovat strojový kód pro mikroprocesory Z80. Jedná se o poměrně rozsáhlý a propracovaný programovací jazyk (navíc jednoduchý na naučení), jemuž bude kvůli rozsahu věnován samostatný článek.

16. Doplnění: makro assemblery pro osobní mikropočítače s mikroprocesorem Motorola 68000

Zastavme se na chvíli u makro assemblerů určených pro počítače s mikroprocesorem Motorola 68000. Mikropočítače Amiga se, podobně jako například i konkurenční počítače Atari ST, velmi často používaly jako herní stroje a navíc se zde rozvinula i „subkultura“ vývojářů, kteří se zabývali programováním audiovizuálních dem. U těchto typů aplikací bylo velmi důležité, aby bylo například vykreslovací jádro co nejrychlejší, takže se programátoři velmi často uchylovali k použití assembleru. Tímto termínem se, jak již víme, poněkud nepřesně označuje jak příslušný jazyk – česky jazyk symbolických adres nebo jazyk symbolických instrukcí, tak i překladač, který zápis v assembleru převede do (binárního) strojového kódu cílového procesoru.

Assemblery byly na počítačích Amiga a Atari ST mezi programátory poměrně populární i díky tomu, že instrukční kód mikroprocesorů Motorola 68000 byl do velké míry ortogonální, obsahoval relativně velké množství registrů (univerzální datové registry D0 až D7 a adresové registry A0 až A7) a navíc bylo možné používat i takové adresovací režimy, které korespondovaly s konstrukcemi používanými ve vyšších programovacích jazycích (přístupy k prvkům polí, přístup k lokálním proměnným umístěných v zásobníkovém rámci, autoinkrementace adresy atd.). Podívejme se na jednoduchý příklad rutiny (originál najdete zde, která sečte všechny prvky (16bitové integery – načítá se vždy jen 16bitové slovo) v poli. V tomto příkladu se používá autoinkrementace adresy při adresování prvků polí a taktéž instrukce DBRA provádí dvě činnosti – snížení hodnoty registru o jedničku a skok v případě, že je výsledek nenulový:

    moveq #0, d0      ; potřebujeme vynulovat horních 16 bitů d0
    moveq #0, d1      ; mezivýsledek
loop:
    move.w (a0)+, d0  ; horních 16 bitů d0 je pořád nastaveno na 0
    add.l d0, d1
    dbra d2, loop     ; d2 je použit jako počitadlo

Jedním z populárních assemblerů dostupných pro mikropočítače Amiga byl assembler nazvaný ASM-One Macro Assembler. Autorem tohoto assembleru je Rune-Gram Madsen, který tento nástroj v průběhu roku 1990 vytvořil za pouhé čtyři týdny. Jednalo se o komerčně dostupný nástroj prodávaný společností DMV Verlag (Německo) za přibližně 139 marek. Ovšem počet reálně prodaných kusů tohoto nástroje byl poměrně nízký – prodalo se pouze přibližně 500 kopií první verze; ovšem na tomto místě je nutné poznamenat, že ASM-One nebyl jedinou aplikací, která měla problémy s prodejem. Podobný osud totiž potkal například i mnoho her, což je jeden z důvodů, proč některé softwarové firmy postupně přešly na jiné platformy.

Dnes si většinou pod pojmem „assembler“, představujeme nástroj spouštěný z příkazového řádku, který překládá zdrojové kódy napsané v jazyku symbolických adres do objektového (binárního) kódu, popř. přímo vytváří spustitelné soubory. Ovšem ASM-One Macro Assembler se od tohoto chápání assemblerů liší, protože se jednalo o plnohodnotné integrované vývojové prostředí vybavené textovým editorem, samotným assemblerem, monitorem a taktéž debuggerem. Celé prostředí bylo přitom naprogramované taktéž v assembleru a velikost binárního balíčku nepřesahovala devadesát kilobajtů.

I pro Atari ST vznikla celá řada assemblerů, například A-SEKA, Macro Assembler, DevpacST, GST-ASM atd. Nejrychlejším assemblerem je A-SEKA, který dokáže přeložit přibližně 30000 řádků kódu za sekundu (a to na čipu s taktovací frekvencí osm MHz – nikoli GHz). Naproti tomu GST-ASM je doplněn o programátorský editor, podporuje pochopitelně makra, připojování dalších souborů (include) atd.

17. Příloha 1: instalace cross assembleru ATasm

Výše zmíněné cross assemblery a cross překladače většinou nejsou dostupné v repositářích linuxových distribucí, takže je nutné jejich ruční překlad a instalace. Je to však většinou jednoduchá a naprosto bezproblémová operace.

Nejprve si ukažme překlad a instalaci ATasmu na Linuxu.

Stažení archivu se zdrojovými kódy ATasmu verze 1.09:

$ wget https://atari.miribilist.com/atasm/atasm109.zip
 
--2021-05-07 18:21:57--  https://atari.miribilist.com/atasm/atasm109.zip
Resolving atari.miribilist.com (atari.miribilist.com)... 64.90.43.178
Connecting to atari.miribilist.com (atari.miribilist.com)|64.90.43.178|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 397661 (388K) [application/zip]
Saving to: ‘atasm109.zip’
 
atasm109.zip   100%[==============================================================================>] 388.34K   108KB/s    in 3.6s
 
2021-05-07 18:22:02 (108 KB/s) - ‘atasm109.zip’ saved [397661/397661]

Rozbalení archivu:

$ unzip atasm109.zip 
 
Archive:  atasm109.zip
   creating: atasm109/
  inflating: atasm109/atasm.exe
   creating: atasm109/docs/
  inflating: atasm109/docs/atasm.blurb
  ...
  ...
  ...

Samotný překlad a slinkování:

$ cd atasm109/src/
$ make
 
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c asm.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c symbol.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c parser.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c setparse.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c state.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c dimage.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c inc_path.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c crc32.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c atasm_err.c
gcc -Wall -DZLIB_CAPABLE -I../zlib  -DUNIX -O3 -fomit-frame-pointer  -c state2.c
gcc -o atasm asm.o symbol.o parser.o setparse.o state.o dimage.o inc_path.o crc32.o atasm_err.o state2.o -L../zlib -lz

Otestování, zda je assembler správně přeložen a zda je spustitelný:

$ ./atasm --version
 
ATasm 1.09 (A mostly Mac65 compatible 6502 cross-assembler)

Překlad testovacího příkladu:

$ ./atasm test.m65 
 
ATasm 1.09 (A mostly Mac65 compatible 6502 cross-assembler)
Pass 1: Success. (0 warnings)
Pass 2: Success. (0 warnings)
 
Assembly successful
  Compiled 289 bytes (~0k)
    Block: 0600-071a (283 bytes)
    Block: 072b-0730 (6 bytes)
 
Compiled to binary file 'test.65o'

Úprava stavového souboru:

$ ./atasm test.m65 -mstatefile.a8s
 
ATasm 1.09 (A mostly Mac65 compatible 6502 cross-assembler)
Pass 1: Success. (0 warnings)
Pass 2: Success. (0 warnings)
 
Assembly successful
  Compiled 289 bytes (~0k)
    Block: 0600-071a (283 bytes)
    Block: 072b-0730 (6 bytes)
 
Compiled to binary file 'test.65o'

18. Příloha 2: instalace cross assembleru xa (xa65)

Dále si ukažme překlad a instalaci xa65, opět na Linuxu.

Stažení archivu se zdrojovými kódy xa65:

$ wget https://www.floodgap.com/retrotech/xa/dists/xa-2.3.11.tar.gz
 
--2021-05-08 08:41:38--  https://www.floodgap.com/retrotech/xa/dists/xa-2.3.11.tar.gz
Resolving www.floodgap.com (www.floodgap.com)... 66.166.122.164
Connecting to www.floodgap.com (www.floodgap.com)|66.166.122.164|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 153864 (150K) [application/x-gzip]
Saving to: ‘xa-2.3.11.tar.gz’
 
xa-2.3.11.tar.gz    100%[===================→] 150.26K  36.7KB/s    in 4.1s
 
2021-05-08 08:41:44 (36.7 KB/s) - ‘xa-2.3.11.tar.gz’ saved [153864/153864]

Rozbalení archivu:

$ tar xvfz xa-2.3.11.tar.gz
 
xa-2.3.11/
xa-2.3.11/COPYING
xa-2.3.11/ChangeLog
...
...
...

Překlad a slinkování:

$ cd xa-2.3.11
 
$ make
 
rm -f xa
(cd src && LD=gcc CC="gcc -O2" make)
make[1]: Entering directory '/tmp/ramdisk/xa-2.3.11/src'
gcc -O2    -c -o xa.o xa.c
gcc -O2    -c -o xaa.o xaa.c
gcc -O2    -c -o xal.o xal.c
gcc -O2    -c -o xap.o xap.c
gcc -O2    -c -o xat.o xat.c
gcc -O2    -c -o xar.o xar.c
gcc -O2    -c -o xar2.o xar2.c
gcc -O2    -c -o xao.o xao.c
gcc -O2    -c -o xau.o xau.c
gcc -O2    -c -o xam.o xam.c
gcc -O2    -c -o xacharset.o xacharset.c
gcc -o ../xa xa.o xaa.o xal.o xap.o xat.o xar.o xar2.o xao.o xau.o xam.o xacharset.o
make[1]: Leaving directory '/tmp/ramdisk/xa-2.3.11/src'
(cd misc && CC="gcc -O2" make)
make[1]: Entering directory '/tmp/ramdisk/xa-2.3.11/misc'
cp mkrom.sh ../mkrom.sh
gcc -O2 -O2 uncpk.c -o ../uncpk
gcc -O2 -O2 printcbm.c -o ../printcbm
gcc -O2 -O2 file65.c -o ../file65
gcc -O2 -O2 reloc65.c -o ../reloc65
gcc -O2 -O2 ldo65.c -o ../ldo65
make[1]: Leaving directory '/tmp/ramdisk/xa-2.3.11/misc'

První spuštění xa65:

$ ./xa
 
Usage: xa [options] file
Cross-assembler for 65xx/R65C02/65816
 
 -v           verbose output
 -C           no CMOS-opcodes
 -W           no 65816-opcodes (default)
 -w           allow 65816-opcodes
 -B           show lines with block open/close
 -c           produce `o65' object instead of executable files (i.e. don't link)
 -o filename  sets output filename, default is `a.o65'
                A filename of `-' sets stdout as output file
 -e filename  sets errorlog filename, default is none
 -l filename  sets labellist filename, default is none
 -r           adds crossreference list to labellist (if `-l' given)
 -M           allow ``:'' to appear in comments for MASM compatibility
 -R           start assembler in relocating mode
 -Llabel      defines `label' as absolute, undefined label even when linking
 -b? addr     set segment base address to integer value addr
                `?' stands for t(ext), d(ata), b(ss) and z(ero) segment
                (address can be given more than once, last one is used)
 -A addr      make text segment start at an address that when the _file_
                starts at addr, relocation is not necessary. Overrides -bt
                Other segments must be specified with `-b?'
 -G           suppress list of exported globals
 -p?          set preprocessor character to ?, default is #
 -DDEF=TEXT   defines a preprocessor replacement
 -Ocharset    set output charset (PETSCII, ASCII, etc.), case-sensitive
 -Idir        add directory `dir' to include path (before XAINPUT)
  --version   output version information and exit
  --help      display this help and exit
== These options are deprecated and will be removed in 2.4+! ==
 -x           old filename behaviour (overrides `-o', `-e', `-l')
 -S           allow preprocessor substitution within strings

19. Příloha 3: instalace MAD Assembleru na Linuxu

MAD Assembler se od předchozích assemblerů odlišuje v tom, že je naprogramovaný v Delphi. Ve skutečnosti se ovšem stále jedná o nástroj ovládaný z příkazové řádky, a dialekt Delphi je podporován v projektu/překladači Free Pascal. To znamená, že překlad MADSu lze provést i na Linuxu, ovšem s jedním přídavným krokem – instalací Free Pascalu.

Instalace překladače Free Pascal na Fedoře, popř. na systému založeném na balíčcích RPM:

$ sudo dnf install fpc

Last metadata expiration check: 0:53:44 ago on Fri 07 May 2021 03:17:18 AM EDT.
Dependencies resolved.
================================================================================
 Package             Arch     Version          Repository                  Size
================================================================================
Installing:
 fpc                 x86_64   3.2.0-1.fc32     updates                     46 M
Installing dependencies:
 SDL2                x86_64   2.0.12-1.fc32    beaker-Fedora-Everything   518 k
 binutils            x86_64   2.34-6.fc32      updates                    5.4 M
 binutils-gold       x86_64   2.34-6.fc32      updates                    852 k
 gpm                 x86_64   1.20.7-21.fc32   beaker-Fedora-Everything   185 k
 info                x86_64   6.7-6.fc32       beaker-Fedora-Everything   228 k
 linuxconsoletools   x86_64   1.7.1-1.fc32     updates                     84 k
 
Transaction Summary
================================================================================
Install  7 Packages
 
Total download size: 53 M
Installed size: 372 M
Is this ok [y/N]:

Kontrola instalace – zda je překladač dostupný a spustitelný:

$ fpc
 
Free Pascal Compiler version 3.2.0 [2020/06/21] for x86_64
Copyright (c) 1993-2020 by Florian Klaempfl and others
/usr/bin/fpc [options]  [options]
 Only options valid for the default or selected platform are listed.

Naklonování repositáře se zdrojovými kódy MAD assembleru:

Root školení Elk

$ git clone https://github.com/tebe6502/Mad-Assembler
 
Cloning into 'Mad-Assembler'...
remote: Enumerating objects: 779, done.
remote: Counting objects: 100% (42/42), done.
remote: Compressing objects: 100% (42/42), done.
remote: Total 779 (delta 22), reused 0 (delta 0), pack-reused 737
Receiving objects: 100% (779/779), 7.71 MiB | 11.49 MiB/s, done.
Resolving deltas: 100% (158/158), done.

Překlad MAD Assembleru:

$ fpc -Mdelphi -vh -O3 mads.pas
 
Hint: Start of reading config file /etc/fpc.cfg
Hint: End of reading config file /etc/fpc.cfg
Free Pascal Compiler version 3.2.0 [2020/06/21] for x86_64
Copyright (c) 1993-2020 by Florian Klaempfl and others
Target OS: Linux for x86-64
Compiling mads.pas
mads.pas(1095,5) Note: Local variable "i" is assigned but never used
mads.pas(3684,29) Hint: Local variable "par" of a managed type does not seem to be initialized
mads.pas(4633,28) Warning: Local variable "tmp" of a managed type does not seem to be initialized
mads.pas(6222,10) Warning: Local variable "par" of a managed type does not seem to be initialized
mads.pas(8255,49) Warning: Local variable "str" of a managed type does not seem to be initialized
mads.pas(8856,46) Warning: Local variable "all" does not seem to be initialized
mads.pas(9757,26) Hint: Local variable "par" of a managed type does not seem to be initialized
mads.pas(12703,47) Hint: Local variable "txt" of a managed type does not seem to be initialized
mads.pas(10235,27) Hint: Local variable "par" of a managed type does not seem to be initialized
mads.pas(12703,51) Hint: Local variable "tmp" of a managed type does not seem to be initialized
mads.pas(11683,52) Warning: Local variable "idx" does not seem to be initialized
mads.pas(11683,51) Warning: Local variable "idx" does not seem to be initialized
mads.pas(12703,53) Hint: Local variable "v" does not seem to be initialized
mads.pas(12823,54) Hint: Local variable "r" does not seem to be initialized
mads.pas(13211,29) Hint: Local variable "tmpZM" of a managed type does not seem to be initialized
Linking mads
15772 lines compiled, 0.6 sec
6 warning(s) issued
10 hint(s) issued
1 note(s) issued

Nyní by měl být MAD Assembler spustitelný z příkazové řádky:

$ ./mads
 
mads 2.1.3
Syntax: mads source [switches]
-b:address      Generate binary file at specific address
-bc             Branch condition test
-c              Label case sensitivity
-d:label=value  Define a label
-f              CPU command at first column
-fv:value       Set raw binary fill byte to [value]
-hc[:filename]  Header file for CC65
-hm[:filename]  Header file for MADS
-i:path         Additional include directories
-l[:filename]   Generate listing
-m:filename     File with macro definition
-ml:value       margin-left property
-o:filename     Set object file name
-p              Print fully qualified file names in listing and error messages
-s              Suppress info messages
-t[:filename]   List label table
-u              Warn of unused labels
-vu             Verify code inside unreferenced procedures
-x              Exclude unreferenced procedures

20. Odkazy na Internetu

  1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari
    https://www.root.cz/clanky/pro­gramovaci-jazyky-pouzivane-na-platforme-osmibitovych-domacich-mikropocitacu-atari/
  2. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari (2)
    https://www.root.cz/clanky/pro­gramovaci-jazyky-pouzivane-na-platforme-osmibitovych-domacich-mikropocitacu-atari-2/
  3. Sedmdesátiny assemblerů: lidsky čitelný strojový kód
    https://www.root.cz/clanky/sed­mdesatiny-assembleru-lidsky-citelny-strojovy-kod/
  4. Programovací jazyk BASIC na osmibitových mikropočítačích
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-osmibitovych-mikropocitacich/
  5. Programovací jazyk BASIC na osmibitových mikropočítačích (2)
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-osmibitovych-mikropocitacich-2/#k06
  6. Programovací jazyk BASIC na herní konzoli Atari 2600
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-herni-konzoli-atari-2600/
  7. A Tour of 6502 Cross-Assemblers
    https://bumbershootsoft.wor­dpress.com/2016/01/31/a-tour-of-6502-cross-assemblers/
  8. Which cross assembler/compiler do you use?
    https://atariage.com/forum­s/topic/195253-which-cross-assemblercompiler-do-you-use/
  9. Stránka magazínu (diskmagu) FLOP
    http://flop.atariportal.cz/
  10. Madass
    https://mads.atari8.info/
  11. MAD-ASSEMBLER 1.9.5
    https://mads.atari8.info/mad­s_eng.html
  12. Action (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Action
  13. Assembler (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Assembler
  14. Basic (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Basic
  15. C (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=C
  16. Forth (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Forth
  17. Fortran (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Fortran
  18. Lisp (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Lisp
  19. Logo (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Logo
  20. Pascal (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Pascal
  21. Pilot (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Pilot
  22. PL65 (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=PL65
  23. Quick (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Quick
  24. WSFN (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=WSFN
  25. MAC/65 (Wikipedia)
    https://en.wikipedia.org/wiki/MAC/65
  26. Atari Assembler Editor
    https://en.wikipedia.org/wi­ki/Atari_Assembler_Editor#A­MAC
  27. cc65
    https://cc65.github.io/
  28. Grafika na osmibitových počítačích firmy Sinclair
    http://www.root.cz/clanky/grafika-na-osmibitovych-pocitacich-firmy-sinclair/
  29. Stránky RetroFestu
    http://retrofest.cz/
  30. RetroHerna
    http://retroherna.cz/
  31. BASIC
    http://cs.wikipedia.org/wiki/BASIC
  32. BASIC
    http://en.wikipedia.org/wiki/BASIC
  33. Rosetta Code – Category Basic
    http://rosettacode.org/wi­ki/Category:BASIC
  34. Dartmouth College Computation Center: 1964 – The original Dartmouth BASIC manual
    http://www.bitsavers.org/pdf/dar­tmouth/BASIC_Oct64.pdf
  35. The Original BASIC
    http://www.truebasic.com/
  36. BASIC – Beginners All-purpose Symbolic Instruction Code
    http://hopl.murdoch.edu.au­/showlanguage.prx?exp=176
  37. Turbo BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Turbo_BASIC
  38. Sinclair BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Sinclair_BASIC
  39. Action!
    https://atari8bitbot.com/action/
  40. Atari Logo
    https://atari8bitbot.com/atari-logo/
  41. Atari PILOT & Super PILOT
    https://atari8bitbot.com/atari-pilot/
  42. Turbo-BASIC XL
    https://atari8bitbot.com/turbo-basic-xl/
  43. Atari Assembler/Editor
    https://atari8bitbot.com/atari-assembler-editor/
  44. Strings in Atari BASIC
    http://www.cyberroach.com/a­nalog/an11/strings.htm
  45. String Arrays in Atari BASIC
    http://www.atarimagazines­.com/compute/issue11/52_1_STRIN­G_ARRAYS_IN_ATARI_BASIC.php
  46. An Atari BASIC Tutorial
    http://www.cyberroach.com/a­nalog/an25/basictutorial.htm
  47. Atari Logo
    https://en.wikipedia.org/wi­ki/Atari_Logo
  48. Computer art and animation: a user's guide to Atari logo
    https://archive.org/detail­s/Computer_Art_and_Animati­on
  49. Going into Action! with Atari XL/XE – Part 1 – Hello World!
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-1-hello-world/
  50. Going into Action! with Atari XL/XE – Part 2 – Graphics
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-2-graphics/
  51. Going into Action! with Atari XL/XE – Part 3 – More Variables, Memory and Pointers (ugh!)
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-3-more-variables-memory-and-pointers-ugh/
  52. Going into Action! with Atari XL/XE – Part 4 – Using VSCode and Action! with syntax highlighting
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-4-using-vscode-and-action-with-syntax-highlighting/
  53. Atari800 (emulátor)
    https://github.com/atari800/atari800
  54. Atari MAC/65 Tutorial
    https://www.youtube.com/wat­ch?v=RyBsGDJBXD0
  55. MAC/65 Manual
    http://www.mixinc.net/atari/mac65.htm
  56. BASIC 10 Liner Contest 2021
    https://atariage.com/forum­s/topic/316645-basic-10-liner-contest-2021/
  57. Hexadecimální prohlížeče a editory s textovým uživatelským rozhraním
    https://www.root.cz/clanky/he­xadecimalni-prohlizece-a-editory-s-textovym-uzivatelskym-rozhranim/
  58. Deep Blue C
    https://en.wikipedia.org/wi­ki/Deep_Blue_C
  59. Deep Blue C Compiler
    https://www.atariarchives­.org/APX/showinfo.php?cat=20166
  60. Historie vývoje počítačových her: simulace a strategické hry naprogramované Chrisem Crawfordem
    https://www.root.cz/clanky/historie-vyvoje-pocitacovych-her-simulace-a-strategicke-hry-naprogramovane-chrisem-crawfordem/
  61. Explore BASIC Programming Languages for the Atari 8-Bit Computers (30–60 mins)
    http://atariprojects.org/2020/08/29/ex­plore-different-basic-programming-languages-for-the-atari-8-bit-computers-30–60-mins/
  62. Learn How to Make a Game in BASIC XE (30–60 mins)
    http://atariprojects.org/2019/12/21/le­arn-how-to-make-a-game-in-basic-xe-30–60-mins/
  63. Atari BASIC XL (manuál)
    http://www.atarimania.com/8bit/fi­les/BASIC%20XL%20%C2%A4%20Se­cond%20Edition.pdf
  64. BASIC XE For Atari XL & XE
    https://www.atarimagazines­.com/compute/issue67/318_1_Re­views_BASIC_XE_For_Atari_XL_XE­.php
  65. BUG/65 (Reference manual)
    https://atariwiki.org/wiki/at­tach/Bug65/BUG-65%20Version%202.0%20manual-final%20with%20errorpage.pdf
  66. Cross compiler
    https://en.wikipedia.org/wi­ki/Cross_compiler
  67. Křížový překladač
    https://cs.wikipedia.org/wi­ki/K%C5%99%C3%AD%C5%BEov%C3%BD_p%C5%99e­klada%C4%8D
  68. ATasm
    https://atari.miribilist.com/atasm/
  69. ATasm v1.09 („Global Pandemic Release“)
    https://atari.miribilist.com/a­tasm/atasm.pdf
  70. DOS XL
    https://en.wikipedia.org/wiki/DOS_XL
  71. Aztec C online Museum
    https://www.clipshop.ca/Az­tec/index.htm
  72. Aztec C Compilers
    http://aztecmuseum.ca/compilers.htm
  73. Scratchbox
    http://scratchbox.org/
  74. History of PC based C-compilers
    https://web.archive.org/web/20071215083657/htt­p://www.itee.uq.edu.au/~csmweb/de­compilation/hist-c-pc.html
  75. PAL/NTSC Upgrade
    https://www.myatari.com/nirdary.html
  76. How can you measure time using BASIC on Atari XL computers?
    https://retrocomputing.stac­kexchange.com/questions/269/how-can-you-measure-time-using-basic-on-atari-xl-computers
  77. Atari Microsoft Basic manual
    http://www.atarimania.com/8bit/fi­les/Atari_Microsoft_Basic­.pdf
  78. Assembly Language: Still Relevant Today
    http://wilsonminesco.com/AssyDefense/
  79. Programovani v assembleru na OS Linux
    http://www.cs.vsb.cz/gryga­rek/asm/asmlinux.html
  80. Why Assembly Language Programming? (Why Learning Assembly Language Is Still a Good Idea)
    https://wdc65×x.com/market­s/education/why-assembly-language-programming/
  81. Low Fat Computing
    http://www.ultratechnology­.com/lowfat.htm
  82. Assembly Language
    https://www.cleverism.com/skills-and-tools/assembly-language/
  83. Why do we need assembly language?
    https://cs.stackexchange.com/qu­estions/13287/why-do-we-need-assembly-language
  84. Assembly language (Wikipedia)
    https://en.wikipedia.org/wi­ki/Assembly_language#Histo­rical_perspective
  85. Assembly languages
    https://curlie.org/Computer­s/Programming/Languages/As­sembly/
  86. vasm
    http://sun.hasenbraten.de/vasm/
  87. A86/A386 assembler and D86/D386 debugger
    http://eji.com/a86/
  88. FASM
    https://en.wikipedia.org/wiki/FASM
  89. NASM
    https://www.nasm.us/
  90. High Level Assembly (home page)
    http://plantation-productions.com/Webster/
  91. High Level Assembly (Wikipedia)
    https://en.wikipedia.org/wi­ki/High_Level_Assembly
  92. A86/A386 Features
    http://eji.com/a86/features­.htm#FeaturesA86
  93. Assembly language today
    http://beust.com/weblog/2004/06/23/as­sembly-language-today/
  94. Assembler: Význam assembleru dnes
    http://www.builder.cz/rubri­ky/assembler/vyznam-assembleru-dnes-155960cz
  95. Assembler pod Linuxem
    http://phoenix.inf.upol.cz/li­nux/prog/asm.html
  96. AT&T Syntax versus Intel Syntax
    https://www.sourceware.or­g/binutils/docs-2.12/as.info/i386-Syntax.html
  97. Linux Assembly website
    http://asm.sourceforge.net/
  98. Using Assembly Language in Linux
    http://asm.sourceforge.net/ar­ticles/linasm.html
  99. Borland Turbo Assembler
    https://web.archive.org/web/20101023185143/htt­p://info.borland.com/borlan­dcpp/cppcomp/tasmfact.html
  100. Microsoft Macro Assembler Reference
    https://docs.microsoft.com/en-us/cpp/assembler/masm/microsoft-macro-assembler-reference?view=vs-2019
  101. ASM-One Macro Assembler
    http://en.wikipedia.org/wiki/ASM-One_Macro_Assembler
  102. ASM-One pages
    http://www.theflamearrows­.info/documents/asmone.html
  103. Základní informace o ASM-One
    http://www.theflamearrows­.info/documents/asminfo.html
  104. xa65
    https://www.floodgap.com/re­trotech/xa/
  105. ca65 Users Guide
    https://cc65.github.io/doc/ca65.html
  106. Introduction of Assembler
    https://www.geeksforgeeks­.org/introduction-of-assembler/
  107. Two Pass Assemblers Tutorial
    https://www.youtube.com/wat­ch?v=BUZycVrWPa4
  108. ST ASSEMBLERS A START COMPARISON
    https://www.atarimagazines­.com/startv1n1/STAssembler­s.html

Autor článku

Pavel Tišnovský vystudoval VUT FIT a v současné době pracuje ve společnosti Red Hat, kde vyvíjí nástroje pro OpenShift.io.