Hardcore vývoj a ladění programů pro osmibitová Atari s využitím Turbo Monitoru a tabulky instrukcí

Z pohledu dnešního vývojáře sice mohou všechny tři zmíněné vývojové nástroje vypadat velmi spartánsky, ovšem pro situaci před cca 40–45 lety se ve skutečnosti jednalo o uživatelsky přívětivé nástroje (další revoluce nastala až s příchodem integrovaných vývojových prostředí Turbo Pascalu a dalších programovacích jazyků – to je však jiná oblast informatiky, která se už netýká osmibitových počítačů Atari).

Nicméně vyvíjet (a do jisté míry i ladit) aplikace bylo možné i s využitím ještě jednodušších prostředků, než jsou assemblery a debuggery. Příkladem může být tuzemský Turbo Monitor, což byl program používaný mj. pro úpravu a převod programů do formátu Turbo 2000 (jak již ostatně naznačuje jeho název). Ovšem díky tomu, že tento nástroj obsahuje kromě klasických operací, které si s monitory spojujeme, i disassembler a navíc i možnost spouštět strojový kód umístěný na libovolné adrese, lze ho použít i pro další činnosti – úpravu her pro nekonečný počet životů, ladění existujících programů, ale i (a to je již poměrně hardcode i na osmdesátá léta minulého století) pro vývoj nových programů „na zelené louce“.

Co je tedy pro takový vývoj zapotřebí? Ve skutečnosti jen zcela minimální prostředky, o to však větší znalosti (tedy naprostý opak k vibe codingu):

1. Atari a magnetofon s úpravou na Turbo 2000 (v moderní době emulátor osmibitových mikropočítačů Atari)
2. Turbo Monitor na kazetě nebo na cartridge
3. Tabulka s kódy strojových instrukcí mikroprocesoru MOS 6502 (nebo několik dále popsaných menších tabulek, což je praktičtější)
4. Mapa registrů čipů ANTIC, GTIA a POKEY (vývoj her) popř. výpis adres subrutin operačního systému a DOSu (vývoj uživatelského SW)
5. Čtverečkovaný papír A4+tužka – ukazuje se, že právě toto jsou nejdůležitější dva nástroje!

Kódy strojových instrukcí mikroprocesoru MOS 6502

Vzhledem k tomu, že Turbo Monitor neobsahuje plnohodnotný assembler, který by dokázal převádět symbolická jména instrukcí a symbolické adresy (návěští) do strojového kódu, je nutné tuto činnosti provádět ručně a vrátit se tak vlastně na začátek padesátých let minulého století, kdy ještě plnohodnotné assemblery vlastně neexistovaly. U moderních architektur mikroprocesorů, které obsahují tisíce různých variant instrukcí a nepřeberné množství jejich kódování (adresovací režimy, prefixy atd.), by takový přístup byl velmi složitý, ovšem osmibitový mikroprocesor MOS 6502 je v tomto ohledu mnohem jednodušší. Dokáže totiž vykonat pouze 56 strojových instrukcí a i když mnohé instrukce podporují různé adresovací režimy, je jejich kódování do určité míry pravidelné, což zjednodušuje ruční zápis strojového kódu.

Nejprve si uveďme seznam všech podporovaných instrukcí:

Následuje seznam všech podporovaných adresovacích režimů. Právě adresovací režimy odlišují mikroprocesor MOS 6502 od naprosté většiny ostatních mikroprocesorů a umožňují použít odlišný styl programování založený na efektivním použití nulté stránky paměti a jednoho z index registrů (každý z nich má nepatrně odlišné možnosti). Existuje celkem třináct (!) adresovacích režimů, ovšem žádná instrukce nevyužívá všechny dostupné režimy. Některé adresovací režimy jsou určeny pouze pro skoky, další pro implicitní operandy atd.:

Jsou kódy instrukcí zvoleny podle nějakého schématu?

V případě, že všechny možné existující kombinace instrukcí a adresovacích režimů zapíšeme do často používané mřížky 16×16 buněk, budeme moci zjistit, jestli jsou instrukce stejného typu seskupeny podle vyššího nibblu a/nebo nibblu nižšího (nibblem se označuje čtveřice bitů). Získáme tedy tabulku se všemi instrukčními kódy, které jsou na mikroprocesoru MOS 6502 podporovány. Mnohé instrukce ovšem (zcela pochopitelně) za instrukčním kódem očekávají další jeden až dva bajty s konstantou či adresou:

Rozdělení instrukcí do tří hlavních skupin

Výše uvedená tabulka naznačuje, že kódy nebyly instrukcím přiřazeny zcela náhodně, ale že zde skutečně existují nějaká pravidla. Je to ostatně logické, protože pravidelná a do určité míry ortogonální instrukční sada umožňuje zjednodušit dekodér instrukcí (ten na MOS 6502 zabírá přibližně jednu třetinu plochy čipu). Z výše uvedené tabulky lze tato pravidla odvodit. Informace uvedené ve zbytku této kapitoly byly získány především ze stránky The 6502/65C02/65C816 Instruction Set Decoded, která se zabývá (a to do všech detailů) právě tímto tématem.

Operační kód instrukce, což je vždy jen jeden bajt, lze reprezentovat třemi skupinami bitů aaa, bbb a cc, které tvoří výsledný bajt ve formátu aaabbbcc. Bity ze skupin aaa a cc určují typ instrukce (například LDA), zatímco bity ze skupiny bbb slouží ke specifikaci adresního režimu (například (ZP,X)).

Na základě hodnoty bitů ze skupiny cc je možné instrukce rozdělit do tří množin (teoretická čtvrtá množina je prázdná):

Odlišné kódování mají pouze instrukce pro podmíněné skoky. Bity instrukčního kódu mají vzorek xxy10000, kde xx určuje příznakový bit a y určuje, zda se skok provede v případě, že je příznakový bit vynulován či naopak nastaven.

Tabulky instrukcí rozdělených do logických skupin

Pro programátora, který používá Turbo Monitor, nemusí být výše uvedená tabulka se všemi instrukcemi příliš přehledná. Praktičtější je instrukce rozdělit logicky, ideálně na základě bitů ze skupiny cc zmíněné v předchozím textu, do několika menších tabulek, které vlastně mají oproti předchozí tabulce „inverzní“ strukturu (v původní tabulce jsou uloženy kódy instrukcí, kdežto typ instrukce a adresovací režim je zapsán v hlavičkách sloupců a řádků). Výsledky mohou vypadat následovně:

Operace s akumulátorem, tedy instrukce s bity cc nastavenými na hodnotu 01, mají ortogonální strukturu a tabulka tak pokrývá největší skupinu instrukcí, které podporují shodné adresovací režimy:

Operace s index registry, bitové posuny a rotace:

Operace s index registry a skoky:

Instrukce skoků s podmínkou:

Zbylé instrukce, které nezapadají do žádného schématu:

Prostředí Turbo Monitoru

Nyní již máme k dispozici tabulky instrukcí, takže je možné se začít zabývat samotným Turbo Monitorem. Po jeho spuštění by měla obrazovka tohoto nástroje vypadat následovně:

Ovládání Turbo Monitoru

Ovládání Turbo Monitoru se provádí jednopísmennými příkazy popř. kombinací Ctrl+klávesa. Příkazy lze rozdělit na práci se zařízeními a práci s pamětí:

Prohlížení obsahu paměti: monitor a disassembler

Turbo monitor umožňuje prohlížení obsahu paměti, a to několika způsoby. Pro programátory a hackery (v původním smyslu tohoto slova) je nejužitečnější výpis paměti zkombinovaný se zpětným dekódováním instrukcí. Po zadání příkazu D (disassemble) se monitor zeptá na počáteční adresu (opět – pozor na rozdíl mezi decimálními a hexadecimálními adresami) a poté se po každém stisku Enteru vypíše další instrukce:

Snadno si ověříme, že šestá paměťová stránka je prázdná a můžeme do ní zapisovat naše demonstrační příklady:

Zápis strojového kódu do operační paměti v monitoru

Druhý způsob výpisu obsahu paměti je spuštěn příkazem M neboli monitor. Opět je nutné zadat počáteční adresu. Monitor postupně vypisuje obsah paměti a očekává buď potvrzení klávesou Enter nebo zadání nových hodnot, které se ihned do paměti zapíšou. Nejprve si ukažme pouhý výpis obsahu paměti:

Nyní se dostáváme k prvnímu demonstračnímu příkladu. V něm se pouze nastavuje barva pozadí textu na černou. V assembleru vypadá výpis takového kódu jednoduše:

*=   $0600
LDA  #0
STA  710
BRK

Ovšem my dnes nemáme k dispozici assembler, ale jen monitor. Musíme tedy s využitím tabulek zmíněných výše provést ruční převod symbolických jmen instrukcí do strojového kódu:

A9 00       LDA  #0
8D C6 02    STA  710
00          BRK

Pouze strojový kód tedy vypadá takto:

A9 00
8D C6 02
00

A přesně tuto sekvenci bajtů (tak jak je uvedena, tedy ve stejném pořadí) zapíšeme v režimu monitoru na adresy $0600 až $0605:

Spuštění první verze programu

Stiskneme Reset pro ukončení režimu monitoru a výběrem příkazu D (disassembler) a zadáním adresy 0600 si ověříme, že zapsaná sekvence šesti bajtů skutečně odpovídá požadovaným instrukcím:

Výborně, vše se zdá být zcela korektní. Proto opustíme režim disassembleru (například opět Resetem) a příkazem G provedeme spuštění programu zapsaného v šesté stránce paměti. Program je sice ukončen (konkrétně v našem případě instrukcí BRK), ale obrazovka se zdánlivě vůbec nezměnila – pozadí je stále zelené a nikoli černé. A po dokončení programu se vypíše obsah všech registrů. Z tohoto výpisu lze ověřit, že program skončil na adrese $0605 (správně) a akumulátor A je vynulován (opět správně):

Úprava programu: přidání nekonečné programové smyčky

Program ve skutečnosti změnil barvu pozadí, ovšem po dokončení jeho běhu si Turbo monitor obnovil vlastní display list i obsah barvových registrů. To je rozumné, protože například při ladění hry je vhodné se vždy vrátit k čitelnému textovému režimu. Ovšem jak dosáhnout toho, aby byly změny provedené programem skutečně vizuálně viditelné? Je to snadné – program zacyklíme – nikdy se tedy nevykoná instrukce BRK. Pro jednoduchost použijeme instrukci nepodmíněného skoku JMP a (opět pro jednoduchost – nechce se mi provádět výpočty adres) budeme skákat na začátek programu, tedy na adresu $0600:

LDA  #0
STA  710
JMP  0600

Ruční překlad do assembleru (pozor na zápis adresy dolní/horní bajt):

A9 00       LDA  #0
8D C6 02    STA  710
4C 00 06    JMP  0600

Výsledný strojový kód:

A9 00
8D C6 02
4C 00 06

Opět se přepneme do režimu monitoru a program přepíšeme novými instrukcemi:

Disassemblerem si ověříme, že byly jak kódy instrukcí, tak i konstanta a dvě adresy zapsány korektně:

Spuštění upraveného programu

Po spuštění programu příkazem G 0600 by se skutečně měla změnit barva pozadí obrazovky. Následně se program zacyklí a vzhledem k tomu, že nikdy neprovede instrukci BRK, zůstane obrazovka v tomto stavu:

Výpočet adres pro podmíněné skoky

V předchozím demonstračním příkladu jsem schválně použil instrukci pro absolutní nepodmíněný skok JMP, protože bylo dopředu známé, na jakou adresu se skok provede. Ovšem všechny skoky s podmínkou (je jich celkem osm, vždy dvě instrukce pro každý příznak) používají relativní adresu:

Tato adresa je uložena v jediném bajtu, který reprezentuje osmibitovou hodnotu se znaménkem, tj. v rozsahu –128 až 127. Ovšem otázkou zůstává, od jaké přesné adresy se tato relativní adresa počítá? Každá architektura mikroprocesorů k tomuto problému přistupuje různě – například se provádí výpočet od adresy instrukce skoku nebo dokonce od adresy za kódem této instrukce. V případě mikroprocesoru MOS 6502 je situace snadnější – adresa se počítá od instrukce, která následuje za instrukcí podmíněného skoku.

Co to znamená v praxi?:

• Bajty F0 00 představují instrukci BEQ, která v případě splnění podmínky skočí na instrukci zapsanou ihned za skokem (a jedná se tedy o poněkud divně zapsanou instrukci NOP).
• Bajty 90 01 představují instrukci BCC, která v případě splnění podmínky přeskočí bajt následující za touto instrukcí. Pokud podmínka není splněna, je tento bajt přečten a příslušná instrukce je vykonána.
• Bajty F0 FE představují instrukci BEQ, která v případě splnění podmínky zopakuje sebe samu – a vstoupí tak do nekonečné smyčky. FE totiž znamená offset –2 a instrukce BEQ má přesně délku dvou bajtů.

Příklad s podmíněnými skoky

Pokusme se nyní demonstrační příklad upravit do takové podoby, aby se v něm použila dvojice podmíněných skoků. První z těchto instrukcí provádí skok vpřed – přeskočí se instrukce BRK (ta by totiž program ihned ukončila). A druhá z těchto instrukcí realizuje nekonečnou smyčku, tj. skok se provede na tu samou instrukci (opět: pokud by tato část byla napsána špatně, provede se BRK). Vycházím se přitom z faktu, že do akumulátoru je vložena nulová hodnota a tím pádem instrukce LDA nastaví příznak zero na jedničku (pozor – to je specifikum čipu MOS 6502; další mikroprocesory se takto nechovají):

      CLC
      BCC NEXT
      BRK
NEXT  LDA #0
      STA 710
REPT  BEQ 60
      BRK

Ruční překlad do strojového kódu:

18                CLC
90 01             BCC NEXT
00                BRK
A9 00       NEXT  LDA #0
8D C6 02          STA 710
F0 FE       REPT  BEQ 60
00                BRK

Pouze strojový kód:

18
90 01
00
A9 00
8D C6 02
F0 FE
00

Program ve strojovém kódu přepíšeme v monitoru do paměti:

A disassemblerem zkontrolujeme výsledek, zejména to, zda skoky používají korektní cílové adresy (disassembler je dokáže spočítat):

Spuštění příkladu a ověření v emulátoru, že je příklad vykonáván korektně

Takto upravený demonstrační příklad spustíme běžným způsobem, tj. s využitím G 0600 (opět: pozor na hexadecimální zápis adresy). Program by nikdy neměl vykonat instrukci BRK, ale měl by skončit v nekonečné smyčce. Obrazovka by měla zčernat a vypadat následovně:

Jak si však u programu běžícího v nekonečné smyčce ověříme, co vlastně provádí? Pokud program spouštíme v emulátoru počítačů Atari, je to relativně snadné. Klávesou F8 přejdeme do monitoru, ovšem nikoli do Turbo Monitoru, ale do monitoru, který je zabudován přímo v emulátoru. Měla by se zobrazit informace o tom, že se provádí instrukce BEQ $0609 umístěná na stejné adrese:

  0   2 A=00 X=FF Y=04 S=FB P=--*---Z- PC=0609: F0 FE     BEQ $0609

Příkazem d 0600 (vidíte tu podobnost s Turbo Monitorem?) si necháme zobrazit instrukce uložené od adresy $0600:

> d 0600
 
0600: 18        CLC
0601: 90 01     BCC $0604
0603: 00        BRK
0604: A9 00     LDA #$00
0606: 8D C6 02  STA $02C6   ;COLOR2
0609: F0 FE     BEQ $0609
060B: 00        BRK
060C: 00        BRK
060D: 00        BRK
060E: 00        BRK
060F: 00        BRK
0610: 00        BRK

Vše se tedy zdá být v naprostém pořádku.

Disassembling subrutin uložených v paměti ROM

Vzhledem k tomu, že při práci Turbo Monitoru je ROM „přiklopena“ (je namapována do adresového prostoru čipu MOS 6502), můžeme si prohlédnout různé subrutiny, které jsou zde uloženy. Příkladem je subrutina pro kreslení využívaná mj. i Atari BASICem:

Disassembling s výstupem na zvolené zařízení

Jen v krátkosti se podívejme na způsob disassemblingu části paměti s tím, že se výsledek nezobrazí přímo na obrazovce, ale pošle se do zvoleného zařízení:

Výsledkem bude soubor s následujícím obsahem, který ukazuje limity tohoto přístupu (neznámé instrukce atd.):

$FCFC:  STA  $3F      $85 $3F
$FCFE:  LDA #$01      $A9 $01
$FD00:  JSR  $FDFC    $20 $FC $FD
$FD03:  BMI  $FD2E    $30 $29
$FD05:  LDA #$34      $A9 $34
$FD07:  STA  $D302    $8D $02 $D3
$FD0A:  LDX  $62      $A6 $62
$FD0C:  LDY  $FE93,X  $BC $93 $FE
$FD0F:  LDA  $FE91,X  $BD $91 $FE
$FD12:  TAX           $AA
$FD13:  ???           $F2
$FD14:  TAY           $A8
$FD15:  STA  $022A    $8D $2A $02
$FD18:  JSR  $E45C    $20 $5C $E4
$FD1B:  LDA  $022A    $AD $2A $02
$FD1E:  BNE  $FD1B    $D0 $FB
$FD20:  LDA #$80      $A9 $80
$FD22:  STA  $3D      $85 $3D
$FD24:  STA  $028A    $8D $8A $02
$FD27:  JMP  $FD77    $4C $77 $FD
$FD2A:  LDY #$80      $A0 $80
$FD2C:  DEC  $11      $C6 $11
$FD2E:  LDA #$00      $A9 $00
$FD30:  STA  $0289    $8D $89 $02
$FD33:  RTS           $60
$FD34:  LDA #$80      $A9 $80
$FD36:  STA  $0289    $8D $89 $02
$FD39:  LDA #$02      $A9 $02
$FD3B:  JSR  $FDFC    $20 $FC $FD
$FD3E:  BMI  $FD2E    $30 $EE
$FD40:  LDA #$CC      $A9 $CC
$FD42:  STA  $D204    $8D $04 $D2
$FD45:  LDA #$05      $A9 $05
$FD47:  STA  $D206    $8D $06 $D2
$FD4A:  LDA #$60      $A9 $60
$FD4C:  STA  $0300    $8D $00 $03
$FD4F:  JSR  $E468    $20 $68 $E4
$FD52:  LDA #$34      $A9 $34
$FD54:  STA  $D302    $8D $02 $D3
$FD57:  LDX  $62      $A6 $62
$FD59:  LDY  $FE8F,X  $BC $8F $FE
$FD5C:  LDA  $FE8D,X  $BD $8D $FE
$FD5F:  TAX           $AA
$FD60:  ???           $F2
$FD61:  LDA #$20      $A9 $20
$FD63:  ???           $5C
$FD64:  CPX  $A9      $E4 $A9
$FD66:  ???           $FF
$FD67:  STA  $022A    $8D $2A $02
$FD6A:  LDA  $11      $A5 $11
$FD6C:  BEQ  $FD2A    $F0 $BC
$FD6E:  LDA  $022A    $AD $2A $02
$FD71:  BNE  $FD6A    $D0 $F7
$FD73:  LDA #$00      $A9 $00
$FD75:  STA  $3D      $85 $3D
$FD77:  LDY #$01      $A0 $01
$FD79:  RTS           $60
$FD7A:  LDA  $3F      $A5 $3F
$FD7C:  BMI  $FDB1    $30 $33
$FD7E:  LDX  $3D      $A6 $3D
$FD80:  CPX  $028A    $EC $8A $02
$FD83:  BEQ  $FD8D    $F0 $08
$FD85:  LDA  $0400,X  $BD $00 $04
$FD88:  INC  $3D      $E6 $3D
$FD8A:  LDY #$01      $A0 $01
$FD8C:  RTS           $60
$FD8D:  LDA #$52      $A9 $52
$FD8F:  JSR  $FE3F    $20 $3F $FE
$FD92:  TYA           $98
$FD93:  BMI  $FD8C    $30 $F7
$FD95:  LDA #$00      $A9 $00
$FD97:  STA  $3D      $85 $3D
$FD99:  LDX #$80      $A2 $80
$FD9B:  LDA  $03FF    $AD $FF $03
$FD9E:  CMP #$FE      $C9 $FE
$FDA0:  BEQ  $FDAF    $F0 $0D
$FDA2:  CMP #$FA      $C9 $FA
$FDA4:  BNE  $FDA9    $D0 $03
$FDA6:  LDX  $047F    $AE $7F $04
$FDA9:  STX  $028A    $8E $8A $02
$FDAC:  JMP  $FD7A    $4C $7A $FD
$FDAF:  DEC  $3F      $C6 $3F
$FDB1:  LDY #$88      $A0 $88
$FDB3:  RTS           $60
$FDB4:  LDX  $3D      $A6 $3D
$FDB6:  STA  $0400,X  $9D $00 $04
$FDB9:  INC  $3D      $E6 $3D
$FDBB:  LDY #$01      $A0 $01
$FDBD:  CPX #$7F      $E0 $7F
$FDBF:  BEQ  $FDC2    $F0 $01
$FDC1:  RTS           $60
$FDC2:  LDA #$FC      $A9 $FC
$FDC4:  JSR  $FE7C    $20 $7C $FE
$FDC7:  LDA #$00      $A9 $00
$FDC9:  STA  $3D      $85 $3D
$FDCB:  RTS           $60
$FDCC:  LDY #$01      $A0 $01
$FDCE:  RTS           $60
$FDCF:  LDA  $0289    $AD $89 $02
$FDD2:  BMI  $FDDC    $30 $08
$FDD4:  LDY #$01      $A0 $01
$FDD6:  LDA #$3C      $A9 $3C
$FDD8:  STA  $D302    $8D $02 $D3
$FDDB:  RTS           $60
$FDDC:  LDX  $3D      $A6 $3D
$FDDE:  BEQ  $FDEA    $F0 $0A
$FDE0:  STX  $047F    $8E $7F $04
$FDE3:  LDA #$FA      $A9 $FA
$FDE5:  JSR  $FE7C    $20 $7C $FE
$FDE8:  BMI  $FDD6    $30 $EC
$FDEA:  LDX #$7F      $A2 $7F
$FDEC:  LDA #$00      $A9 $00
$FDEE:  STA  $0400,X  $9D $00 $04
$FDF1:  DEX           $CA
$FDF2:  BPL  $FDEE    $10 $FA
$FDF4:  LDA #$FE      $A9 $FE
$FDF6:  JSR  $FE7C    $20 $7C $FE
$FDF9:  JMP  $FDD6    $4C $D6 $FD
$FDFC:  STA  $40      $85 $40
$FDFE:  LDA  $14      $A5 $14
$FE00:  CLC           $18

Závěr

Podle názoru autora článku není vývoj aplikací přímo v monitoru prakticky možný, alespoň ne pro běžného vývojáře (zcela jistě se ovšem najdou geniální výjimky). Jakýkoli program delší než cca padesát strojových instrukcí je tedy mnohem lepší nejdříve navrhnout na papíře, provést zde první ruční refaktoring, přepsat výsledek refaktoringu do monitoru (resp. do paměti), uložit na paměťové médium, spustit a ověřit funkcionalitu (samozřejmě lze vynechat fázi ukládání, ostatně co by se tak mohlo pokazit, že?). Výsledkem mnohdy bývá strojový kód s mnoha „poslepovanými“ částmi (vyplněné NOPy atd.), ten je ovšem většinou možné v poslední fázi (zcela mechanicky) přepsat do strukturovanější podoby. Samotné ladění spočívá ve vkládání instrukcí BRK na místa, ve kterých by se v debuggeru použily breakpointy. Taktéž se tedy jedná o poměrně hardcore přístup, ovšem stále může být (pro jednodušší programy i hry) udržitelný.

Repositář s demonstračními příklady

Všechny demonstrační příklady, s nimiž jsme se v předchozích článcích i v článku dnešním seznámili a které jsou určeny pro překlad s využitím assembleru ca65, jsou dostupné, jak je zvykem, na GitHubu. V tabulce níže jsou uvedeny odkazy na jednotlivé zdrojové kódy příkladů psané v assembleru i „listingy“ vygenerované samotným assemblerem, ze kterých je patrné, jakým způsobem se jednotlivé příklady přeložily do výsledného XEX souboru:

Odkazy na Internetu

1. MOS 6502 instruction set
   http://www.6502.org/users/o­belisk/6502/instructions.html
2. EXE File Format Description
   https://gury.atari8.info/ref­s/file_formats_exe.php
3. XEX Filter – A toolkit to analyze and manipulate Atari binary files
   https://www.vitoco.cl/atari/xex-filter/index.html
4. chkxex.py
   https://raw.githubusercon­tent.com/seban-slt/tcx_tools/refs/heads/mas­ter/chkxex.py
5. ca65 Users Guide
   https://cc65.github.io/doc/ca65.html
6. cc65 Users Guide
   https://cc65.github.io/doc/cc65.html
7. ld65 Users Guide
   https://cc65.github.io/doc/ld65.html
8. da65 Users Guide
   https://cc65.github.io/doc/da65.html
9. Překladače jazyka C pro historické osmibitové mikroprocesory
   https://www.root.cz/clanky/prekladace-jazyka-c-pro-historicke-osmibitove-mikroprocesory/
10. Překladače programovacího jazyka C pro historické osmibitové mikroprocesory (2)
    https://www.root.cz/clanky/prekladace-programovaciho-jazyka-c-pro-historicke-osmibitove-mikroprocesory-2/
11. Getting Started Programming in C: Coding a Retro Game with C Part 2
    https://retrogamecoders.com/getting-started-with-c-cc65/
12. NES game development in 6502 assembly – Part 1
    https://kibrit.tech/en/blog/nes-game-development-part-1
13. NES 6502 Programming Tutorial – Part 1: Getting Started
    https://dev.xenforo.relay­.cool/index.php?threads/nes-6502-programming-tutorial-part-1-getting-started.858389/
14. Minimal NES example using ca65
    https://github.com/bbbradsmith/NES-ca65-example
15. List of 6502-based Computers and Consoles
    https://www.retrocompute.co.uk/list-of-6502-based-computers-and-consoles/
16. 6502 – the first RISC µP
    http://ericclever.com/6500/
17. 3 Generations of Game Machine Architecture
    http://www.atariarchives.or­g/dev/CGEXPO99.html
18. “Hello, world” from scratch on a 6502 — Part 1
    https://www.youtube.com/wat­ch?v=LnzuMJLZRdU
19. A Tour of 6502 Cross-Assemblers
    https://bumbershootsoft.wor­dpress.com/2016/01/31/a-tour-of-6502-cross-assemblers/
20. Adventures with ca65
    https://atariage.com/forum­s/topic/312451-adventures-with-ca65/
21. example ca65 startup code
    https://atariage.com/forum­s/topic/209776-example-ca65-startup-code/
22. 6502 PRIMER: Building your own 6502 computer
    http://wilsonminesco.com/6502primer/
23. 6502 Instruction Set
    https://www.masswerk.at/6502/6502_in­struction_set.html
24. Chip Hall of Fame: MOS Technology 6502 Microprocessor
    https://spectrum.ieee.org/tech-history/silicon-revolution/chip-hall-of-fame-mos-technology-6502-microprocessor
25. Single-board computer
    https://en.wikipedia.org/wiki/Single-board_computer
26. www.6502.org
    http://www.6502.org/
27. 6502 PRIMER: Building your own 6502 computer – clock generator
    http://wilsonminesco.com/6502pri­mer/ClkGen.html
28. Great Microprocessors of the Past and Present (V 13.4.0)
    http://www.cpushack.com/CPU/cpu.html
29. Jak se zrodil procesor?
    https://www.root.cz/clanky/jak-se-zrodil-procesor/
30. Osmibitové mikroprocesory a mikrořadiče firmy Motorola (1)
    https://www.root.cz/clanky/osmibitove-mikroprocesory-a-mikroradice-firmy-motorola-1/
31. Mikrořadiče a jejich použití v jednoduchých mikropočítačích
    https://www.root.cz/clanky/mikroradice-a-jejich-pouziti-v-jednoduchych-mikropocitacich/
32. Mikrořadiče a jejich aplikace v jednoduchých mikropočítačích (2)
    https://www.root.cz/clanky/mikroradice-a-jejich-aplikace-v-jednoduchych-mikropocitacich-2/
33. 25 Microchips That Shook the World
    https://spectrum.ieee.org/tech-history/silicon-revolution/25-microchips-that-shook-the-world
34. Comparison of instruction set architectures
    https://en.wikipedia.org/wi­ki/Comparison_of_instructi­on_set_architectures
35. How To Start Learning Atari 8 Bit Assembly For Free
    https://forums.atariage.com/to­pic/300732-how-to-start-learning-atari-8-bit-assembly-for-free/
36. WUDSN (Demo Group)
    https://www.wudsn.com/
37. Machine Language For Beginners
    https://www.atariarchives.org/mlb/
38. Assembly language: all about I/O
    https://www.atarimagazines­.com/v3n8/AllAbout_IO.html
39. Sedmdesátiny assemblerů: lidsky čitelný strojový kód
    https://www.root.cz/clanky/sed­mdesatiny-assembleru-lidsky-citelny-strojovy-kod/
40. Color names
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Color%20names
41. ATASCII
    https://en.wikipedia.org/wiki/ATASCII
42. Put characters in display ram isn't ATASCII?
    https://forums.atariage.com/to­pic/359973-put-characters-in-display-ram-isnt-atascii/
43. ATASCII And Internal Character Code Values
    https://www.atariarchives­.org/mapping/appendix10.php
44. Reading ATASCII from the keyboard in assembly
    https://forums.atariage.com/to­pic/361733-reading-atascii-from-the-keyboard-in-assembly/
45. Why does the 6502 JSR instruction only increment the return address by 2 bytes?
    https://retrocomputing.stac­kexchange.com/questions/19543/why-does-the-6502-jsr-instruction-only-increment-the-return-address-by-2-bytes
46. Pushing return address to stack off by 1 byte
    https://forums.atariage.com/to­pic/378206-pushing-return-address-to-stack-off-by-1-byte/
47. Intel x86 documentation has more pages than the 6502 has transistors
    https://www.righto.com/2013/09/intel-x86-documentation-has-more-pages.html
48. Clearing a Section of Memory
    http://www.6502.org/source/ge­neral/clearmem.htm
49. Practical Memory Move Routines by Bruce Clark
    http://www.6502.org/source/ge­neral/memory_move.html
50. 6502 Assembly Programming Guide
    https://neumont-gamedev.github.io/posts/retrogamedev-6502-guide/
51. Off-by-one error
    https://en.wikipedia.org/wiki/Off-by-one_error
52. 6502 cycle times
    https://www.nesdev.org/wi­ki/6502_cycle_times
53. Atari TIA
    http://www.atarihq.com/danb/tia.shtml
54. TIA Playfield
    http://www.atarihq.com/dan­b/TIA/Playfield.shtml
55. Atari Inc.:
    ANTIC C012296 (NTSC) Revision D
    Atari Incorporated, Sunnyvale CA, 1982
56. Atari Inc.:
    GTIA C014805 (NTSC) Revision A
    Atari Incorporated, Sunnyvale CA, 1982
57. Atari 5200
    http://www.atariage.com/sof­tware_search.html?SystemID=5200
58. Atari 5200 Hardware and Accessories
    http://www.atariage.com/5200/ar­chives/hardware.html
59. Atari 5200 Screenshots
    http://www.atariage.com/sys­tem_items.html?SystemID=5200&I­temTypeID=SCREENSHOT
60. History of video game consoles (second generation): Wikipedia
    http://en.wikipedia.org/wi­ki/History_of_video_game_con­soles_(second_generation)
61. Atari 5200: Wikipedia
    http://en.wikipedia.org/wi­ki/Atari_5200
62. Player-Missile Graphics
    https://www.atariarchives­.org/agagd/chapter5.php
63. Sprite (computer graphics)
    https://en.wikipedia.org/wi­ki/Sprite_(computer_graphic­s)
64. Atari Graphics Demonstrations by Underground Software, 1985 | Atari 8 bit Demo
    https://www.youtube.com/wat­ch?v=h7N9EYSyCkw
65. Atari 8-bit Display List Interrupts: A Complete(ish) Tutorial
    https://playermissile.com/dli_tu­torial/
66. Atari Assembler Editor manual
    https://atariwiki.org/wiki/at­tach/Atari%20Assembler%20E­ditor/ATARI%20Assembler%20E­ditor%20User-s%20Manual-OCR.pdf
67. Atari 8-bit Fine Scrolling: A Complete(ish) Tutorial
    https://playermissile.com/scro­lling_tutorial/index.html
68. Atari Fine Scrolling
    https://www.atarimagazines­.com/compute/issue67/338_1_A­tari_Fine_Scrolling.php
69. CTIA / GTIA Pinout Diagram
    https://user.xmission.com/~tre­vin/atari/gtia_pinout.html
70. GTIA Modes
    https://page6.org/archive/is­sue_02/page_10.htm
71. 56 graphic modes
    https://www.atari800×l.eu/docs/kb/kb-hardware-0005-atari-8bit-56-graphic-modes.html
72. UNLOCKING THE 56 GRAPHIC MODES
    https://www.atarimagazines­.com/v3n5/allmodes.html
73. GTIA Modes 9, 10 & 11 + ANTIC data and color clocks
    https://forums.atariage.com/to­pic/366256-gtia-modes-9–10–11-antic-data-and-color-clocks/
74. ANTIC, GTIA and timing info
    https://atarimax.com/jindrou­sh.atari.org/atanttim.html
75. 6.10 Cycle timing
    https://github.com/AnimaIn­Corpore/A8E/blob/main/AHRM/6­.%20CTIA-GTIA/10.%20Cycle%20timing.md
76. Doug Neubauer
    https://en.wikipedia.org/wi­ki/Doug_Neubauer
77. POKEY
    https://en.wikipedia.org/wiki/POKEY
78. Inside the Atari 800XL
    https://www.goto10retro.com/p/800×l-inside
79. Grayscale Project – „Jam Session“ – Chiptune Visualization / Atari SAP
    https://www.youtube.com/watch?v=Qx-AHgvwrHo&list=PL92E73FD91764173B
80. POKEY MUSIC ( ATARI XL / XE ) =+ MUSIC FROM POLAND += DEMO
    https://www.youtube.com/wat­ch?v=5PswfMjMop4&list=RD5PswfMjMop4&star­t_radio=1
81. Atari.org
    http://www.atari.org/
82. Atari POKEY
    http://www.absoluteastrono­my.com/topics/Atari_POKEY
83. Chiptune
    http://www.absoluteastrono­my.com/topics/Chiptune
84. ASAP – Another Slight Atari Player
    http://asap.sourceforge.net/
85. Atari SAP music archive
    http://asma.atari.org/
86. RASTER Music Tracker (RMT)
    http://raster.infos.cz/ata­ri/rmt/rmt.htm
87. POKEY explorer
    https://github.com/ivop/pokey-explorer
88. POKEY C012294 Documentation
    https://7800.8bitdev.org/in­dex.php/POKEY_C012294_Docu­mentation
89. Pokey Registers
    https://user.xmission.com/~tre­vin/atari/pokey_regs.html
90. POKEY CO12294
    http://krap.pl/mirrorz/ata­ri/homepage.ntlworld.com/kry­ten_droid/Atari/800XL/ata­ri_hw/pokey.htm
91. De Re Atari: SOUND
    https://www.atariarchives­.org/dere/chapt07.php#H7_3_5
92. Paddle (game controller)
    https://en.wikipedia.org/wi­ki/Paddle_(game_controller)
93. Interfacing Your Atari
    https://www.atariarchives­.org/creativeatari/Interfa­cing_Your_Atari.php
94. Atari SIO
    https://en.wikipedia.org/wi­ki/Atari_SIO
95. Atari Chips
    https://atarimax.com/jindrou­sh.atari.org/achip.html
96. Table 4: Keyboard Code Index, KEYCODE: ATASCII
    https://www.atariarchives­.org/c3ba/kcindex.php
97. SIO2PC
    http://raster.atariportal­.cz/hw/sio2pc.htm
98. Using Serial Input/Output
    https://www.atarimagazines­.com/compute/issue64/insig­ht_atari.php
99. SIO ROUTINES
    https://www.atariarchives­.org/mmm/sio.php
100. ATARI 8 bit Serial Input/Output (SIO)
     https://allpinouts.org/pi­nouts/connectors/serial/a­tari-8-bit-serial-input-output-sio/
101. SIOspecs
     https://archive.org/details/SIOspecs
102. Interview with Joe Decuir
     http://www.atarimuseum.com/ar­ticles/joedecuir.html
103. USB AND OS/2
     http://www.os2voice.org/VNL/pas­t_issues/VNL1199H/vnewsf5­.htm
104. Standards and specs: The ins and outs of USB
     http://www.ibm.com/develo­perworks/power/library/pa-spec7.html
105. USB Class Codes
     http://www.usb.org/develo­pers/defined_class
106. Universal Serial Bus
     http://en.wikipedia.org/wiki/Usb
107. SMBus.org
     http://www.smbus.org
108. SMBus FAQ
     http://www.smbus.org/faq/faq.htm
109. System Management Bus
     http://en.wikipedia.org/wi­ki/System_Management_Bus
110. SMBus Specifications
     http://www.smbus.org/specs
111. SMBus Control Method Interface Specification Version 1.0
     http://www.smbus.org/spec­s/smbus_cmi10.pdf
112. System Management Bus (SMBus) Specification Version 2.0
     http://www.smbus.org/spec­s/smbus20.pdf
113. Atari Connection Machine
     http://acm.atariportal.cz/s/con8bit/8bits
114. Atari Program Recorder
     https://en.wikipedia.org/wi­ki/Atari_Program_Recorder
115. THE ATARI CASSETTE
     https://www.atariarchives­.org/dere/chaptC.php
116. Turbo-2000
     https://www.atari-800.cz/turbo-2000
117. Atari XC12 FSK Decoder
     https://zeninstruments.blog­spot.com/2024/08/atari-xc12-fsk-decoder.html
118. Clock recovery
     https://en.wikipedia.org/wi­ki/Clock_recovery
119. Jiří Richter (programátor)
     https://cs.wikipedia.org/wi­ki/Ji%C5%99%C3%AD_Richter_(pro­gram%C3%A1tor)
120. Spectrum tape interface
     https://sinclair.wiki.zxnet­.co.uk/wiki/Spectrum_tape_in­terface
121. How Tape Loading Works
     https://lemmings.info/how-tape-loading-works/
122. CIO Reference
     https://atarifoundry.com/doc­s/forge/advanced-topics/cio-reference
123. The central input-output system in Atari computers
     https://www.atariarchives­.org/alp/chapter_9.php
124. ATR: chpt.1: Central Input/Output (CIO)
     https://www.atariarchives­.org/cfn/12/02/0010.php
125. NOTE and POINT
     https://atarifoundry.com/doc­s/forge/advanced-topics/note-point
126. Customizing the Atari Operating System Device Handlers: Part 1
     https://www.atarimagazines­.com/v8n2/customhandlers.html
127. Customizing the Atari Operating System Device Handlers: Part II
     https://www.atarimagazines­.com/v8n3/OperatingSystem­Handlers.html
128. Spectrum tape interface
     https://sinclair.wiki.zxnet­.co.uk/wiki/Spectrum_tape_in­terface
129. Turbo 2000
     http://wiki.oldcomp.cz/in­dex.php?title=Turbo_2000
130. Původní manuál k systému Turbo 2000
     http://wiki.oldcomp.cz/ima­ges/6/65/Zak_praha_1987_p2_tur­bo2000.pdf
131. Mark and space
     https://en.wikipedia.org/wi­ki/Mark_and_space
132. Obdélníkový průběh
     https://cs.wikipedia.org/wi­ki/Obd%C3%A9ln%C3%ADkov%C3%BD_pr%C5%AF­b%C4%9Bh
133. All you ever wanted to know about: Atari Cartridges
     https://atariwiki.org/wiki/Wi­ki.jsp?page=Cartridges
134. Manuál k MAC/65
     https://data.atariwiki.org/DOC/MAC-65_and_BUG-65_Rev._1.1-OSS-OCR.pdf
135. Manuál k DDT
     https://atariwiki.org/wiki/at­tach/DDT/DDT_1.0_Manual.pdf
136. MAC/65 na Atari wiki
     https://www.atariwiki.org/wi­ki/Wiki.jsp?page=Mac65
137. Madass – home page
     https://mads.atari8.info/
138. Mad-Assembler (GitHub)
     https://github.com/tebe6502/Mad-Assembler
139. The 6502/65C02/65C816 Instruction Set Decoded
     https://llx.com/Neil/a2/opcodes.html