Hlavní navigace

Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari (2)

13. 4. 2021
Doba čtení: 35 minut

Sdílet

 Autor: Frank Ostrowski
V dnešním článku budeme pokračovat v tématu, kterému jsme se začali věnovat minulý týden. Popíšeme si totiž některé další významné programovací jazyky a programátorské pomůcky dostupné pro osmibitové domácí mikropočítače Atari.

Obsah

1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari

2. Stručná historie společnosti Optimized Systems Software (OSS)

3. Debugger BUG/65

4. BASIC A+

5. BASIC XL

6. BASIC XE

7. Atari Microsoft BASIC

8. Atari Microsoft BASIC II

9. Doplnění: grafika na mikropočítačích Atari založená na čipech ANTIC a GTIA

10. Porovnání rychlosti některých interpretrů jazyka BASIC pro osmibitová Atari

11. Výsledek prvního benchmarku

12. Výsledek druhého benchmarku

13. Fast BASIC

14. Překladače vyšších programovacích jazyků pro osmibitová Atari

15. Programovací jazyk Pascal

16. Kyan Pascal

17. Cross compilery a cross assemblery

18. Obsah závěrečného článku

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

20. Odkazy na Internetu

1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari

V úvodním článku o vývojových nástrojích dostupných na osmibitových domácích mikropočítačích Atari jsme si popsali některé významné assemblery, zejména pak Atari Assembler Editor a taktéž MAC/65. Poté jsme se zabývali popisem dvou důležitých interpretrů programovacího jazyka BASIC; konkrétně se jednalo o Atari BASIC a taktéž o slavný Turbo BASIC XL.

Obrázek 1: Úvodní obrazovka Turbo-BASICu XL.

Zmínili jsme se i o dalších interpretovaných programovacích jazycích, konkrétně o Interlispu/65 a taktéž o programovacím jazyku Atari LOGO. Nezapomněli jsme ovšem ani na programovací jazyk Forth, konkrétně na jeho dialekt pojmenovaný FIG Forth. A nakonec jsme se zmínili o překladačích, konkrétně o programovacím jazyku Action!, který vznikl pouze pro počítače Atari a přes jeho přednosti se nakonec příliš neprosadil.

Obrázek 2: Pracovní (kreslicí) plocha v Atari LOGu.

Na článek s výše uvedeným stručným obsahem dnes navážeme. V první části se ve stručnosti zmíníme o historii společnosti OSS, druhá část bude věnována popisu dalších důležitých interpretrů programovacího jazyka BASIC, v části třetí porovnáme tyto interpretry s vyžitím značně zjednodušených benchmarků a konečně v části čtvrté se zmíníme o některých překladačích určených pro osmibitová Atari (navážeme tak na část věnovanou jazyku Action!).

Obrázek 3: Interpret Interlispu/65.

Poznámka na úvod: tento článek je, stejně jako článek úvodní, zkrácenou verzí rozsáhlejšího článku, který vyjde v magazínu (přesněji řečeno diskmagu) FLOP určeného (nejenom) pro skalní Ataristy. Všechny předchozí díly FLOPu je možné spustit v prakticky libovolném emulátoru osmibitových Atari, například v multiplatformním emulátoru atari800.

Obrázek 4: Prostředí programovacího jazyka Action!

2. Stručná historie společnosti Optimized Systems Software (OSS)

Zastavme se ještě na chvíli u assembleru MAC/65 a programovacího jazyka Action!, které byly zmíněny v úvodní kapitole. Za vznikem těchto vývojářských nástrojů stála jediná firma OSS neboli plným jménem Optimized Systems Software. Tato společnost se orientovala převážně na vývoj nástrojů užitečných pro vývojáře, a to jak pro amatéry (v kladném smyslu tohoto slova), tak i pro profesionální společnosti. Tato firma vznikla v roce 1981, takže by letos oslavila (pokud by ovšem existovala – ovšem jen málo firem přežilo hektickou dobu IT mezi lety 1980 až přibližně 1995) kulaté výročí svého vzniku.

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

Historie společnosti OSS se začala psát vlastně již se vznikem Atari BASICu. Víme, že Atari BASIC vlastně vznikl až poté, co se ukázalo, že společnost Micro-Soft nedokáže svůj Atari Microsoft BASIC „nacpat“ do požadované kapacity ROM – osmi kilobajtů (ovšem Atari Microsoft BASIC byl nakonec vydán, a to dokonce ve dvou verzích, jak uvidíme dále). Za vznikem OSS stáli Bill Wilkinson, Mike Peters, Paul Laughton a Kathleen O'Brien, přičemž třetí jmenovaný vydal Atari BASIC a jeho žena Kathleen pracovala mj. i na FP rutinách operačního systému Atari. Původní Atari BASIC a taktéž první verze DOSu byla odkoupena od společnosti Shepardson Microsystems, která ukončila svoji existenci právě v roce 1981 a kde původně zakladatelé OSS pracovali. V dalších letech se OSS věnovala jak rozšiřování možností původních produktů (řada DOS, řada BASICů), tak i dalším projektům, mj. i jazyku Action!

Obrázek 6: Debugger DDT vestavěný do assembleru MAC/65.

Příkladem produktu OSS je OS/A+, tedy dosový systém založený na systému menu. Později vznikl DOS XL, který podporoval diskety s dvojnásobnou hustotou a kromě menu se ovládal i příkazovou řádkou nazývanou CP neboli command processor. OSS vyvinula i takzvanou supercartridge s kapacitou 16kB.

Příklad menu z DOSu XL:

 C - Copy Files            P - Protect Files
 D - Duplicate Disk        Q - Quit to DOS XL
 E - Erase Files           R - Rename File
 F - Files on Disk         S - Save Binary
 G - Go to Address         T - To Cartridge
 I - Initialize Disk       U - Unprotect Files
 L - Load Binary           X - Xtended Command

Na příkazovém řádku byly podporovány interní příkazy, mezi něž patří například D1: (přepnutí disků), DIR, END, ERA atd. A většinou byly k dispozici i příkazy externí: COPY, DUPDSK, VERIFY atd.

Obrázek 7: DOS dodávaný společně s jazykem Action! Konkrétně se jedná o DOS XL.

Z portfolia společnosti OSS stojí za zmínku především:

  • Interpretry BASICu rozšiřující a zrychlující původní Atari BASIC: BASIC A+, BASIC XL a BASIC XE
  • Assemblery a debuggery: EASMD (Edit/ASseMble/Debug) vydaný již v roce 1981, MAC/65, BUG/65
  • Další programovací jazyky či jejich překladače: Action!, C/65, Tiny C interpretr subsetu jazyka C, Personal Pascal pro Atari ST 1987

Obrázek 8: Jednoduchý program s procedurou INIT, která odpovídá céčkovskému main, zde ovšem používající syntaxi jazyka Action!

3. Debugger BUG/65

V úvodní kapitole jsme se zmínili mj. o tom, že společnost OSS vyvinula mj. i programátorský nástroj nazvaný BUG/65 (což je mimochodem zajímavé jméno, podobně jako kdyby výrobce automobilů pojmenoval svůj model Šrot). Jedná se o poměrně pokročilý debugger, který ovšem obsahuje i možnosti monitoru a současně i jednoduchého assembleru s interaktivním zápisem instrukcí a dalších jazykových konstrukcí. Původně měl být BUG/65 dodáván společně s assemblerem MAC/65, ovšem nakonec byl dodáván samostatně, a to jak ve verzi pro cartridge, tak i v disketové verzi (společně s DOSem od stejné společnosti; existuje ovšem i kombinace MAC/65+BUG/65).

Obrázek 9: Jeden z prodávaných „bundlů“ – DOS XL + MAC/65 + BUG/65.

Poznámka: mimochodem, možnosti debuggeru BUG/65 jsou skutečně na dobu vzniku poměrně velké. Ostatně i samotná firma OSS se v manuálu omlouvá zákazníkům, že kvůli velkému množství funkcí obsadí BUG/65 velké množství operační paměti – celých osm kilobajtů!

Obrázek 10: Úvodní obrazovka debuggeru BUG/65 (barvy jsou na tomto screenshotu pravé).

BUG/65 podporuje přibližně čtyřicet operací. Patří mezi ně operace, které očekáváme od monitorů: práce s operační pamětí, tj. zobrazení obsahu vybraného bloku, zápis do paměti, zápis řetězce do paměti, porovnání dvou bloků paměti či výplň vybraného bloku. Blok paměti je možné zapsat na disketu, připojit k existujícímu souboru či ho pochopitelně nahrát zpět z diskety do paměti. Podporována je i nízkoúrovňová práce s disketovými sektory. BUG/65 taktéž obsahuje disassembler, dokáže nastavovat breakpointy, specifikovat počet opakování průchodu breakpointem, trasovat (krokovat) programy po jednotlivých instrukcích, provádět krokování s přeskokem subrutin (JSR); zobrazit je pochopitelně i obsah pracovních registrů mikroprocesoru MOS 6502 i jeho příznakových bitů NV-BDIZC. Při všech těchto operacích lze samotný BUG/65 ochránit před přepisem. Třetí částí je assembler, který je řádkově orientovaný – každý řádek se zkontroluje a přeloží do strojového kódu.

Poznámka: trasování/krokování jen poskytováno jen pro RAM, protože BUG/65 musí neustále do strojového kódu vkládat instrukce BRK a to v ROM (či EPROM v cartridge) není možné.

Obrázek 11: Porovnání dvou bloků operační paměti.

BUG/65 obsahuje vlastní ovladač bufferu příkazového řádku, takže není podporován celoobrazovkový editor dostupný v OS. Lze vkládat více příkazů na řádek, poslední řádek je možné opakovat stiskem ENTER, u zadávání adres atd. jsou podporovány základní aritmetické operátory a vkládání hodnot lze realizovat jak v desítkové, tak i v hexadecimální soustavě. Nejzajímavější příkazy jsou:

A zápis ASCII řetězce do paměti na zadanou adresu
C porovnání dvou bloků paměti (start, end, start)
D zobrazení obsahu bloku paměti
F výplň bloku paměti
G skok na adresu
L vyhledání sekvence hexa čísel v paměti
T trace - krokování/trasování
TS krokováni s přeskokem subrutin
Y disassembler (start, end)
V zobrazení obsahu registrů
Z assembler

Obrázek 12: Disassembler podporovaný nástrojem BUG/65.

Zápis více příkazů na řádku:

D 1000 1010  D 2000 2010

Vzhledem k tomu, že druhý parametr u příkazu D je volitelný, musí se zkrácený zápis provést takto:

D 1000, D 2000 2010

Obrázek 13: Zobrazení obsahu pracovních registrů.

4. BASIC A+

V roce 1983 byl společností OSS vydán dialekt BASICu pojmenovaný BASIC A+. Tento dialekt obsahoval opravy a vylepšení původního Atari BASICu a navíc byl tento interpret rychlejší, než původní BASIC (viz též výsledky benchmarků uvedených v jedenácté a dvanácté kapitole). Zajímavé je, že BASIC A+ nebyl dodáván na cartridge, ale na disketě, a to společně se systémem OS/A+ a EASMD (Editor/Assembler). Celková cena za tyto tři programy byla 80 dolarů, takže je patrné že se jednalo o jiný segment trhu, než tomu bylo v případě profesionálnějších nástrojů BUG/65 a MAC/65. Samotný interpret zabral dalších 15 kB RAM. Byl (jak již víme) rychlejší než původní Atari BASIC, obsahoval základní podporu pro PMG (sprity) a taktéž základní podporu pro ladění programů.

Obrázek 14: Úvodní obrazovka BASIC A+.

Díky přímé podpoře OS/A+ došlo k úpravám (resp. k vylepšením) následujících příkazů jazyka BASIC, přičemž některé příkazy (konkrétně poslední čtyři) byly nově přidány:

CLOSE
ENTER
GET
INPUT
LIST
LOAD
NOTE
OPEN
POINT
PRINT
PUT
SAVE
PROTECT (XIO 35)
UNPROTECT (XIO 36)
RENAME (XIO 32)
ERASE (XIO 33)

Obrázek 15: Samotný interpret zabral dalších 15 kB RAM a nepracoval s odklopenou ROM, což je zde jasně patrné.

5. BASIC XL

O další rok později, tedy v roce 1984, vydala společnost OSS další interpret programovacího jazyka BASIC, který byl pojmenován BASIC XL, a to podle toho, že běžel na systémech Atari XL (s plnou RAM) a pochopitelně taktéž na Atari XE. Opět se jednalo o poměrně významné vylepšení a rozšíření možností původního BASICu, k dispozici byly i metody k urychlení výsledných (interpretovaných) programů.

Obrázek 16: Úvodní obrazovka BASICu XL.

První vylepšení spočívá v možnosti příkazem FAST provést přepočet cílů skoků, což má za následek citelné urychlení běhu programů. Dále byla přidána podpora pro dvourozměrné pole řetězců:

DIM A$(10,100)

K přístupu k první a druhé dimenzi se používá středník, protože čárka je již v Atari BASICu použita pro přístup k podřetězcům:

A$(1;)="TEST"

Obrázek 17: Verze na cartridge nabízí stejnou volnou kapacitu RAM, jako původní Atari BASIC.

Přidán byl i příkaz MOVE pro rychlé přesuny bloku paměti. K dispozici je i několik příkazů pro práci se sprity/PMG:

PMGRAPHICS - povolení PMG
PMMOVE - přesun hráče
BUMP - detekce kolize
MISSILE - pozicování střely na y ové souřadnici
PMMOVE - posun hráče -1,0,+1 - podle joysticku
PMWIDTH - šířka hráče
PMCOLOR - barva hráče
PMADR/PMCLR - práce s paměti alokované pro PMG
Poznámka: doplnění informací o spritové grafice bude uvedeno v deváté kapitole.

Užitečné jsou i příkazy VSTICK a HSTICK, které podle náklonu joysticku vrací hodnoty –1, 0 nebo 1, takže není nutné provádět ruční dekódování polohy z čísel 0–15.

Chování interpretru lze ovlivnit příkazem SET, podporováno je trasování (výpis čísel řádků) i automatické číslování řádků. Zapomenout nesmíme ani na chybové zprávy, v nichž se kromě číselných kódů vypisuje i podrobnější informace o typu chyby. A nakonec jsou podporovány další příkazy určené pro strukturované programování:

IF/ELSE/ENDIF
WHILE/ENDWHILE
Poznámka: jedná se o jiné konstrukce, než nabízí Turbo BASIC XL.

Obrázek 18: Automatické odsazení bloků kódu a použití malých písmen v příkazech.

6. BASIC XE

V roce 1985 společnost OSS vydala svoji poslední verzi interpretru programovacího jazyka BASIC pro osmibitová Atari. Tato varianta se jmenovala BASIC XE, a to z toho důvodu, že byl podporován přístup do rozšířené paměti počítačů Atari 130 XE (celkem neuvěřitelných 128 kB RAM) – program bylo možné oddělit do dat, přičemž program byl umístěn ve druhé bance RAM. BASIC XE nabízel i rychlejší matematické operace a oproti BASICu XL nabízel i několik dalších vylepšení (ovšem ne mnoho).

Obrázek 19: Úvodní opbrazovka BASICu XE.

Vzhledem k roku vzniku je patrné, že BASIC XE byl přímou konkurencí k již popsanému Turbo BASICu XL, který byl navíc nabízen ve formě freeware (a nakonec i open source v původním významu tohoto sousloví). Turbo BASIC sice v některých ohledech nedosahoval možností BASICu XL (PMG apod.), ovšem byl rychlejší, podporoval všechny strukturované jazykové konstrukce a samozřejmě v neposlední řadě rozhodovala cena. Ve výsledku byl BASIC XE ztrátovým projektem.

Poznámka: několik čísel o prodejích produktů OSS (různé zdroje se ovšem liší i o desítky procent!): prodalo se 12000 kopií BASICu XL, překladače jazyka Action! pak přibližně 4500 kopií. MAC/65 bylo prodáno cca 6500 kopií.

Obrázek 20: Práce s PMG – černá čárka uprostřed obrazovky je hráč, který je zobrazen nezávisle na pozadí.

7. Atari Microsoft BASIC

Dalším interpretrem programovacího jazyka BASIC, s nímž se v dnešním článku ve stručnosti seznámíme, je Atari Microsoft BASIC. Na historii jeho vzniku jsme již upozornili v předchozím článku – původně totiž měly být domácí osmibitové mikropočítače Atari skutečně dodávány s Microsoft BASICem uloženým v ROM, ovšem nakonec nebylo možné tento interpret umístit do požadovaných osmi kilobajtů ROM, takže jako vhodnější alternativa vznikl Atari BASIC. Nicméně společnost Micro-soft skutečně Atari Microsoft BASIC vydala, a to již v roce 1981. Z několika pohledů se však jedná o dosti rozdílný interpret, než je tomu v (ideové) řadě Atari BASIC → BASIC A+ → BASIC XL → BASIC XE → Turbo BASIC.

Obrázek 21: Atari Microsoft BASIC ponechává programátorům k dispozici pouze 21022 bajtů paměti, což je oproti jiným intepretrům velmi malá hodnota.

Poměrně velký rozdíl spočívá v tom, že se pro výpočty používají odlišné datové typy. Microsoft BASIC totiž podporuje šestnáctibitová celá čísla se znaménkem, hodnoty typu single (s plovoucí řádovou čárkou) uložené ve čtyřech bajtech, hodnoty typu double (taktéž s plovoucí řádovou čárkou) uložené v osmi bajtech a pochopitelně taktéž řetězce. Zcela jsou tedy vynechány šestibajtové hodnoty s plovoucí řádovou čárkou a s nechvalně známými pomalými subrutinami pro výpočty. A navíc – díky použití datových typů single a double je do poměrně velké míry zachována kompatibilita s ostatními interpretry Microsoft BASICu na některých dalších platformách, především na tehdy vznikající platformě IBM PC (a to tehdy s velkou pravděpodobností nikdo ani netušil, jak tato platforma pomůže společnosti Micro-Soft, později Microsoft, v dalším rozvoji).

Typ proměnné bylo možné určit postfixovým znakem:

  • # – typ double
  • % – typ int
  • $ – typ string

Alternativně bylo možné příkazy DEFSNG, DEFDBL, DEFINT či DEFSTR určit typ pro všechny proměnné začínající určitým znakem.

Dalším rozdílem je podpora polí s větším počtem dimenzí. Připomeňme si, že Atari BASIC i Turbo BASIC podporovaly jednorozměrné či dvourozměrné pole s číselnými hodnotami (tedy vlastně vektory a matice) a řetězce považované za jednorozměrná pole znaků. Naproti tomu v Microsoft BASICu mohly mít pole libovolný typ a teoretický počet dimenzí byl omezen na 255 (takže vlastně neomezen, když vezmeme v úvahu pouze cca 21kB volné RAM). Ovšem s touto vlastností souvisí i odlišný přístup k podřetězcům, neboť „atarácký“ zápis A$(od, do) není možné použít – znamená něco jiného, totiž přístup do dvourozměrného znakového pole. Namísto toho jsou dostupné funkce LEFT$, RIGHT$ a MID$, které v Microsoftích interpretrech přežily pravděpodobně až do současnosti.

Obrázek 22: Základní funkce pro práci s řetězci.

V Microsoft BASICu nalezneme i příkaz OPTION, který mění chování interpretru, popř. práci s pamětí. Dostupné jsou tyto varianty tohoto příkazu:

  1. OPTION BASE 0–1: změna indexování polí od nuly nebo jedničky
  2. OPTION PLM0,1,2: rezervace paměti pro PMG (sprity)
  3. OPTION CHR0,1,2: rezervace paměti pro znakovou sadu
  4. OPTION RESERVE : rezervace bloku paměti o specifikované délce

V Microsoft BASICu se objevily i příkazy INKEY$ (čtení klávesy), TIME$, PRINT USING (formátovaný výstup), PRINT AT (výstup na zadané místo), LINE INPUT atd.

Nakonec nesmíme zapomenout na možnost definice jednoduchých jednořádkových funkcí:

DEF AVG(X,Y)=(X+Y)/2

8. Atari Microsoft BASIC II

O rok později po vydání původního Atari Microsoft BASICu (tedy v roce 1982) byla vydána jeho druhá verze s několika opravami a taktéž s několika novými příkazy. Jedná se zejména o příkaz AUTO zajišťující automatické generování čísel řádků a dále o velmi užitečný příkaz MOVE určený pro přesuny paměťových bloků (o dva až tři řády rychlejší, než v samotném BASICu). Příkazem COMMON bylo možné specifikovat ty proměnné, které „přežijí“ samotný program a bude je možné využít v dalším kódu – to teoreticky umožňuje vytvářet moduly, minimálně při použití disketové jednotky.

Obrázek 23: Úvodní obrazovka Microsoft BASICu II.

Další příkazy do jisté míry umožňují programování založené na zachytávání a zpracování událostí. Příkazem AFTER se deklaruje později spouštěný kód; jeho případné vedlejší efekty odstraňuje příkaz CLEAR STACK (navíc existuje i příkaz PRINT STACK). A nejzajímavější je příkaz WAIT … AND, který čeká na změnu provedenou v operační paměti (například rutinou volanou z přerušení) a reaguje na ni.

Obrázek 24: Definice nové funkce na řádku 30, použití této funkce v následujících řádcích.

Teoreticky by měl být interpret Atari Microsoft BASICu II rychlejší, než jeho původní varianta, ovšem z benchmarků vychází spíše opačné výsledky (viz navazující kapitoly).

9. Doplnění: grafika na mikropočítačích Atari založená na čipech ANTIC a GTIA

V předchozích kapitolách jsme se několikrát setkali s termínem sprity a PMG, takže si je nyní ve stručnosti vysvětlíme. Na osmibitových počítačích Atari se grafika skládala ze dvou částí: pozadí (hrací pole, playfield) a pohyblivých rastrových obrázků (spritů, PMG). Pro nastavení grafického režimu pozadí (playfield) byl určen obvod ANTIC (Alpha-Numeric Television Interface Circuit), který umožnil pro každý vykreslovaný řádek (scanline) programově nastavit jeden ze čtrnácti grafických režimů, které se lišily svým rozlišením, počtem současně zobrazitelných barev a velikostí alokované paměti.

S obvodem ANTIC úzce spolupracoval číslicový obvod GTIA (Graphics Television Interface Adapter nebo také George's Television Interface Adapter), který zaváděl podporu pro další tři šestnáctibarevné grafické režimy s horizontálním rozlišením 80 pixelů na řádek, a především umožňoval vykreslování spritů. Současně bylo možné vykreslit čtyři sprity s rozlišením maximálně 8×256 pixelů a další čtyři sprity s rozlišením 2×256 pixelů, které bylo možno spojit do jednoho většího (pátého) spritu s rozlišením 8×256 pixelů.

Sprity široké 8 pixelů se v literatuře nazývají hráči (players), úzké dvoupixelové sprity střely (missiles).

Sprity byly jednobarevné, více barev bylo možno dosáhnout logickými operacemi nad překrývajícími se sprity (počítače Commodore C64 naproti tomu nabízely i sprity v režimu multicolor). Každý sprite mohl pomocí jedné instrukce měnit svoji horizontální velikost i horizontální pozici, přičemž polohy spritů byly navzájem nezávislé.

Vertikální pozice spritů se měnila přesunem bitmapy spritu v operační paměti. Bylo také možné definovat priority vykreslování spritů vůči sobě navzájem i vůči pozadí. Na následujícím obrázku je zobrazen způsob vykreslování grafiky s použitím obvodů ANTIC a GTIA:

Obrázek 25: Základní role čipů ANTIC a GTIA v osmibitových domácích mikropočítačích Atari.

10. Porovnání rychlosti některých interpretrů jazyka BASIC pro osmibitová Atari

Rychlost jednotlivých interpretrů programovacího jazyka BASIC zjistíme s využitím dvojice jednoduchých benchmarků. U obou benchmarků se bude měřit čas běhu části programu, přičemž pro měření použijeme časovač dostupný na adresách 18, 19 a 20. Tento časovač lze programově vynulovat:

10 REM VYMAZANI CASOVACE
11 POKE 18,0
12 POKE 19,0
13 POKE 20,0

Na konci programu zjistíme stav časovače a převedeme ho na sekundy podělením půlsnímkovou frekvencí (50 či 60 Hz podle použité televizní normy):

40 REM PRECTENI CASOVACE
41 REM (PLATNE PRO PAL)
42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
50 PRINT "FINISHED IN ";T;" SECONDS"
Poznámka: více info o časovači je možné najít například v tomto článku.

Obrázek 26: Část prvního benchmarku v prostředí Atari BASICu.

První benchmark je založen na měření doby setřídění padesáti čísel algoritmem bubble sort:

1 REM *****************************
2 REM BUBBLE SORT
3 REM IMPLEMENTACE PRO ATARI BASIC
4 REM UPRAVENO DO PODOBY BENCHMARKU
5 REM *****************************
6 REM
7 REM
8 REM
9 REM
10 REM VYMAZANI CASOVACE
11 POKE 18,0
12 POKE 19,0
13 POKE 20,0
20 REM VLASTNI BENCHMARK
21 MAX=50
22 DIM A(MAX)
23 FOR I=0 TO MAX
24 A(I)=INT(100*RND(0))
25 NEXT I
26 GOSUB 100:REM TISK OBSAHU POLE
27 FOR I=MAX-1 TO 0 STEP -1
28 PRINT ".";
29 FOR J=0 TO I
30 IF A(J)<A(J+1) THEN X=A(J):A(J)=A(J+1):A(J+1)=X
31 NEXT J
32 NEXT I
33 PRINT ""
34 PRINT "SORTED:"
35 GOSUB 100:REM TISK OBSAHU POLE
40 REM PRECTENI CASOVACE
41 REM (PLATNE PRO PAL)
42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
50 PRINT "FINISHED IN ";T;" SECONDS"
99 END
100 REM TISK OBSAHU POLE
101 FOR I=0 TO MAX
102 PRINT I,A(I)
103 NEXT I
104 RETURN

Program je nutné převést z čitelné (textové) podoby do ATASCII, například takto:

tr "\n" "\233" < bench_s.bas > B.BAS

Načtení do interpretru:

ENTER "H:B.BAS"

V případě Microsoft BASICu není příkaz ENTER dostupný, takže se použije:

LOAD "H:B.BAS"
Poznámka: časy běhu se mohou lišit podle toho, jaké náhodné hodnoty byly do pole vloženy. Proto byl program spuštěn několikrát a časy byly zaokrouhleny.

Obrázek 27: Část prvního benchmarku v prostředí Atari BASICu.

Obrázek 28: Výsledek běhu prvního benchmarku.

Obrázek 29: Část prvního benchmarku v prostředí Turbo BASICu XL.

Druhý benchmark je jednodušší a testuje rychlost smyček a přístupu do paměti. Program po svém spuštění zaplní obrazovou paměť náhodnými hodnotami a simuluje tak „sněžení“ analogového televizoru bez antény:

1 REM *****************************
2 REM VYPLNENI OBRAZOVKY NAHODNYM VZOREM
3 REM IMPLEMENTACE PRO ATARI BASIC
4 REM UPRAVENO DO PODOBY BENCHMARKU
5 REM *****************************
6 REM
7 REM
8 REM
9 REM
10 REM VYMAZANI CASOVACE
11 POKE 18,0
12 POKE 19,0
13 POKE 20,0
20 REM VLASTNI BENCHMARK
21 GRAPHICS 8
22 START=PEEK(88)+256*PEEK(89)
23 FINAL=START+320*160/8
30 FOR I=START TO FINAL
35 REM 17BITOVY POLY CITAC = RND
40 POKE I,PEEK(53770)
50 NEXT I
60 REM PRECTENI CASOVACE
70 REM (PLATNE PRO PAL)
80 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
90 PRINT "FINISHED IN ";T;" SECONDS"
99 END

Obrázek 30: Druhý benchmark v prostředí Atari BASICu.

Obrázek 31: Výsledek běhu druhého benchmarku.

11. Výsledek prvního benchmarku

Podívejme se nyní na výsledky prvního benchmarku, který byl prakticky beze změn v programovém kódu spuštěn ve všech osmi klasických interpretrech programovacího jazyka BASIC dostupných na osmibitových Atari. Provedli jsme pouze jedinou změnu, a to na pátém řádku, kdy byl doplněn příkaz FAST, jenž umožňuje přepočítat čísla řádků do podoby umožňující rychlejší (přímé) skoky. A tato změna skutečně způsobila nepatrné vylepšení výsledků (pro BASIC XE se již v případě příkazu FAST vyžaduje 128kB RAM, takže by byl použitelný jen na Atari 130 XE):

Interpret Čas
Atari BASIC 33.46
BASIC A+ 30.10
Turbo BASIC XL 15.86
BASIC XL 18.90
BASIC XL (FAST) 16.32
BASIC XE 20.9
Microsoft Atari BASIC 30.10
Microsoft Atari BASIC II 31.36

Obrázek 32: Výsledek prvního benchmarku se zvýrazněním nejlepšího a nejhoršího výsledku.

Z výsledků je patrné, že nejrychlejší je Turbo BASIC XL, jehož název tedy v žádném případě nelže. Nejpomalejší je původní Atari BASIC, ovšem Microsoft Atari BASIC mu svou „pomalostí“ zdárně sekunduje.

Poznámka: ve skutečnosti je možné program přepsat tak, aby byl v Microsoft BASICu proveden rychleji. Jedná se o náhradu některých proměnných za jejich celočíselné varianty. Po této změně (modifikovaný kód je zvýrazněn) je dosaženo časů 25.87 a 26.96 sekundy (MS BASIC I a II), tedy stále dosti daleko od výkonnosti Turbo BASICu XL:
1 REM ********************************
2 REM BUBBLE SORT PRO POLE TYPU SINGLE
3 REM IMPLEMENTACE PRO MICROSOFT BASIC
4 REM UPRAVENO DO PODOBY BENCHMARKU
5 REM ********************************
6 REM
7 REM
8 REM
9 REM
10 REM VYMAZANI CASOVACE
11 POKE 18,0
12 POKE 19,0
13 POKE 20,0
20 REM VLASTNI BENCHMARK
21 MAX%=50
22 DIM A(MAX%)
23 FOR I%=0 TO MAX%
24 A(I%)=INT(100*RND(0))
25 NEXT I%
26 GOSUB 100:REM TISK OBSAHU POLE
27 FOR I%=MAX%-1 TO 0 STEP -1
28 PRINT ".";
29 FOR J%=0 TO I%
30 IF A(J%)<A(J%+1) THEN X=A(J%):A(J%)=A(J%+1):A(J%+1)=X
31 NEXT J%
32 NEXT I%
33 PRINT ""
34 PRINT "SORTED:"
35 GOSUB 100:REM TISK OBSAHU POLE
40 REM PRECTENI CASOVACE
41 REM (PLATNE PRO PAL)
42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50)
50 PRINT "FINISHED IN ";T;" SECONDS"
99 END
100 REM TISK OBSAHU POLE
101 FOR I%=0 TO MAX%
102 PRINT I%,A(I%)
103 NEXT I%
104 RETURN

12. Výsledek druhého benchmarku

Nyní si zobrazme výsledky druhého benchmarku, tedy vyplnění obrazové paměti náhodnými hodnotami:

Interpret Čas
Atari BASIC 73.28
BASIC A+ 45.88
Turbo BASIC XL 17.14
BASIC XL 34.38
BASIC XL (FAST) 27.06
BASIC XE 63.14
Microsoft Atari BASIC 65.18
Microsoft Atari BASIC II 65.22

Obrázek 33: Výsledek druhého benchmarku se zvýrazněním nejlepšího a nejhoršího výsledku.

Vítěz je v tomto případě opět jasný – je jím Turbo BASIC XL. Druhý nejrychlejší čas dosažený BASICem XL s příkazem FAST je mnohem horší (o celých deset sekund). Nejpomalejší je opět původní Atari BASIC.

Poznámka: druhou variantu pro Microsoft Atari BASIC využívající celá čísla nelze jednoduše vytvořit, i když by to pravděpodobně vedlo k velkému urychlení výpočtů. Důvod je jasný – šestnáctibitové hodnoty se znaménkem nelze použít pro adresování oblasti paměti nad adresou 32767. Řešením by byl posun grafické paměti pod tuto hodnotu.

13. Fast BASIC

Nejnovějším BASICem navrženým a implementovaným pro domácí osmibitové mikropočítače Atari je Fast BASIC. Jedná se projekt, který je v mnoha ohledech odlišný od klasických BASICů – namísto překladu zdrojového kódu do sekvence tokenů se používá překladač do bajtkódu. To je koncept, který známe například z Pythonu, jazyka Lua, Javy atd. (ale i z původního Pascalu). Při běhu programu (tedy v runtime) je bajtkód konvertován na instrukce mikroprocesoru. Výsledek je v každém případě rychlejší, než interpretace tokenizovaného kódu.

Obrázek 34: Vývojové prostředí Fast BASICu.

Mezi další vylepšení patří například podpora pro pole s osmibitovými a 16bitovými hodnotami, což je velmi praktické a pochopitelně to vede i k úsporám operační paměti. Taktéž je možné používat proměnné obsahující celá čísla a tím pádem obejít pomalé FP operace. Změnilo se i vývojové prostředí, protože se již nepoužívá klasický obrazovkový editor s čísly řádků, ale editor, který připomíná Vim – podporován je scrolling atd. (ostatně problematický či nepodporovaný scrolling je jedním z důvodů, proč byla čísla řádků vůbec zavedena).

Obrázek 35: Vývojové prostředí Fast BASICu.

14. Překladače vyšších programovacích jazyků pro osmibitová Atari

Mezi nejpoužívanější jazyky populární v dobách osmibitových domácích mikropočítačů skutečně patřily zejména assemblery a interpretry BASICu, tj. jazyky zmíněné v předchozích kapitolách i v předchozím článku. To ovšem neznamená, že by nabídka programovacích jazyků byla takto omezená. Ve skutečnosti bylo na osmibitové mikropočítače portováno velké množství překladačů vyšších programovacích jazyků, zejména jazyků podporujících procedurální paradigma, tj. skládání programů z procedur (subrutin), v nichž se používají strukturované konstrukce pro tvorbu rozeskoků a programových smyček.

Obrázek 36: Logo překladačů Aztec C.

Z těchto jazyků byl populární především Pascal, a to díky tomu, že tento jazyk byl navržen takovým způsobem, aby byl překlad programů proveden jednoprůchodově a tudíž velmi rychle v porovnání s víceprůchodovými překladači. Ovšem existovaly i další jazyky, například i populární céčko. Zde je nutné zmínit především známý překladač Aztec C portovaný na velké množství různých typů mikropočítačů, zapomenout nesmíme ani na Deep Blue C pro počítače Atari (zde se autoři museli vyrovnat s faktem, že znaková sada neobsahovala složené závorky). V navazujícím textu se zaměříme především na Pascal, konkrétně na Kyan Pascal.

Obrázek 37: Jeden z konkurenčních překladačů k Aztec C byl Lattice C (ovšem až v pozdější době).

15. Programovací jazyk Pascal

O programovacím jazyku Pascal jsme se již zmínili v předchozí kapitole, takže se zde seznámíme s některými technickými zajímavostmi. Překladače Pascalu se typicky používaly na počítačích vybavených buď disketovou jednotkou nebo alespoň paměťovým modulem (s Pascalem) a kazetovým magnetofonem. Disketová jednotka umožňovala relativně rychlé přepínání mezi editorem, překladačem (a linkerem) a spuštěním vytvářené aplikace, tj. vlastně ten styl práce, který se v mnoha případech používá dodnes. Alternativní způsob založený na použití paměťového modulu s ROM či EPROM obsahující editor, překladač i linker, kladlo větší omezení na velikost vytvářené aplikace, protože v jedné chvíli byl (alespoň většinou) v operační paměti uložen jak zdrojový text, tak i přeložená binární aplikace.

Obrázek 38: Manuál k Pascalu určeného pro mikropočítače Commodore C64.

Poznámka: zajímavá je jedna z verzí Pascalu pro československé mikropočítače PMD-85, která se vyznačovala tím, že prakticky všechny texty, kromě samotných klíčových slov jazyka, byly vypisovány česky či slovensky (autor článku se setkal jen s SK verzí). To samozřejmě usnadňovalo použití tohoto jazyka například na školách, protože znalosti a výuka angličtiny nebyla před rokem 1989 z pochopitelných důvodů tou oblastí, na něž by se tehdejší školství zaměřovalo (dokonce existovaly varianty Pascalu s přeloženými klíčovými slovy, screenshot však nemám k dispozici).

Obrázek 39: Paměťový modul s Pascalem pro československé osmibitové mikropočítače PMD-85.

16. Kyan Pascal

Pro osmibitová Atari a taktéž pro počítače Apple II vzniklo několik překladačů Pascalu. Dnes se zmíníme o Kyan Pascalu. Jednalo se o jazyk vydaný až v roce 1987; jde tedy o jeden z nejnovějších nástrojů zmíněných v dnešním článku. Kyan Pascal byl dodáván na disketě a jeho jednotlivé části se musely postupně zavádět a spouštět právě z diskety. K dispozici byl editor, překladač, nástroj pro použití tiskárny atd. atd. Samotný překlad byl prováděn v jednom průchodu (což Pascal ve většině případů umožňuje), takže samotná fáze překladu byla relativně rychlá. Podporována byla většina standardních jazykových konstrukcí. Ke Kyan Pascalu vznikly i různé knihovny, například pro grafiku, práci se želvou, fonty atd.

Obrázek 40: Úvodní obrazovka Kyan Pascalu.

Na disketě byla dodávána i kontextová nápověda:

Obrázek 41: Nápověda.

Zajímavý byl editor použitý v Kyan Pascalu. Ten totiž pracoval jinak, než standardní celoobrazovkový editor (byl blíže chování dnešních editorů) – pokud byl kurzor na konci zapsaného příkazu, znamenal stisk šipky doprava přechod na nový řádek a naopak stisk šipky doleva na začátku řádku převedl kurzor na konec předchozího řádku.

Obrázek 42: Editor Kyan Pascalu.

17. Cross compilery a cross assemblery

V článku o vývojových prostředích a nástrojích určených pro osmibitové domácí mikropočítače Atari pochopitelně nemůžeme zapomenout ani na cross compilery a cross assemblery (viz poznámka o českém překladu tohoto názvu). Tyto typy 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 Scratchbox). Ovšem tato technologie se používala již na začátku osmibitové éry. Například vývoj her pro herní konzoli Atari 2600 (Atari Video Computer System neboli Atari VCS) byl prováděn na minipočítači. Ovšem i později některé firmy vyvíjely profesionální software pro Atari i další osmibitové mikropočítače na výkonnějších strojích, kde se prováděl i překlad.

Poznámka: 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.

Dobrým a možná i typickým příkladem jsou cross překladače programovacího jazyka C. Tvorbou těchto cross překladačů se zabývala například společnost Manx Software Systems, jejíž překladače céčka (Aztec C) určené pro IBM PC s DOSem i pro osobní mikropočítače Macintosh dokázaly provádět cross překlad na osmibitové mikropočítače Commodore C64 a Apple II. Na chvíli se u Aztec C zastavme, i když přímo nesouvisí s osmibitovými Atari.

Aztec C totiž byl ve své době velmi úspěšný překladač, jenž existoval jak ve verzi pro osmibitové mikroprocesory (MOS 6502, Zilog Z-80), tak i pro mikroprocesory 16bitové a 32bitové. Tento překladač byl velmi úspěšný právě na Amize, kde byl používán, společně s Lattice C, prakticky až do faktického zániku této platformy. Ovšem na IBM PC jeho sláva netrvala dlouho, především z toho důvodu, že firma Microsoft považovala segment překladačů za poměrně důležitý a snažila se vytlačit jakoukoli konkurenci z trhu (i když ve skutečnosti v té době ještě neměla vlastní céčkový překladač. Společnosti Manx Software Systems se postupně zmenšoval počet platforem, na něž bylo možné překladač prodávat a přechod na podporu vestavěných systémů již přišel dosti pozdě. A právě pro cross překlad se Aztec C může používat dodnes (běží v DOSu, takže dnes vlastně taktéž v emulovaném prostředí).

Poznámka: další informace o překladačích i cross překladačích Aztec C lze najít na stránce http://aztecmuseum.ca/compilers.htm.

Podobným stylem byl řešen i Microsoft C původně vytvořený společností, která stála za slavným Lattice C. Ostatně Lattice C byl s velkou pravděpodobností vůbec prvním překladačem céčka pro IBM PC (pochází z roku 1982). Ten byl později převeden i na Amigu, dále se rozšířil i na minipočítače a mainframy společnosti IBM. Firma Microsoft překladač Lattice C nabízela pod svým názvem MSC (Microsoft C) a teprve verze MSC 4.0 byla skutečně vytvořena přímo programátory z Microsoftu. Lattice C byl používán i při portaci aplikací z operačního systému CP/M na DOS (dnes je však možné pouze odhadnout, kolik kódu bylo skutečně napsáno v céčku a kolik kódu vzniklo transformací assembleru).

Root_skoleni

18. Obsah závěrečného článku

Ve třetím a současně i posledním článku z tohoto miniseriálku se zaměříme především na popis výše zmíněných cross překladačů a cross assemblerů určených pro osmibitové domácí mikropočítače Atari. Zmíníme se například o projektu ATasm, který je používán dodnes, podobně jako cross překladač programovacího jazyka C.

Poznámka: seriál bude poněkud nepravidelně pokračovat, ovšem zaměříme se přitom na další dobové platformy.

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

Zdrojové kódy dnes i minule ukázaných příkladů byly zveřejněny v repositáři https://github.com/tisnik/8bit-fame/. Vzhledem k odlišnostem mezi ASCII a ATASCII (tedy znakovou sadou používanou v osmibitových mikropočítačích Atari) byly zdrojové kódy převedeny do čitelné podoby, což prakticky znamená, že došlo k převodu znaku pro konec řádku a k dalším nepatrným úpravám (některé emulátory dokážou načíst i takto upravené soubory s využitím zařízení H5):

Příklady pro původní a originální Atari BASIC

# Jméno souboru Stručný popis souboru Cesta
1 1d_array.bas práce s jednorozměrnými poli v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/1d_array.bas
2 2d_array.bas práce s dvourozměrnými poli v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/2d_array.bas
3 bubble_sort.bas algoritmus bublinkového třídění prvků v poli v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/bubble_sort.bas
4 factorial.bas výpočet faktoriálu v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/factorial.bas
5 function1.bas vykreslení průběhu nespojité funkce https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/function1.bas
6 function2.bas vykreslení průběhu funkce https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/function2.bas
7 game.bas jednoduchá hra naprogramovaná na dvou řádcích https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/game.bas
8 GCD.bas výpočet největšího společného dělitele v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BASIC/GCD.bas
9 harmonic.bas zjištění limitů FP hodnot https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/harmonic.bas
10 moire1.bas moaré v grafickém režimu 7 https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/moire1.bas
11 moire2.bas moaré v grafickém režimu 9 https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/moire2.bas
12 moire3.bas moaré v grafickém režimu 11 https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/moire3.bas
13 PI.bas výpočet Pi v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BASIC/PI.bas
14 PMG1.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/PMG1.bas
15 PMG2.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/PMG2.bas
16 printed1.bas problematika proměnné pojmenované PRINTED (zadáno uživatelem) https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/printed1.bas
17 printed2.bas problematika proměnné pojmenované PRINTED (pochopeno překladačem) https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/printed2.bas
18 slides.bas náhrada za neohrabaný PowerPoint https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/slides.bas
19 snowcrash.bas simulace „sněhu“ na televizoru bez příjmu signálu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/snowcrash.bas
20 strings.bas zpracování řetězců v Atari BASICu https://github.com/tisnik/8bit-fame/blob/master/Atari%20BA­SIC/strings.bas

Příklady pro Turbo BASIC XL

# Jméno souboru Stručný popis souboru Cesta
1 1d_array.bas práce s jednorozměrnými poli v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/1d_array.bas
2 2d_array.bas práce s dvourozměrnými poli v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/2d_array.bas
3 bubble_sort.bas algoritmus bublinkového třídění prvků v poli v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/bubble_sort.bas
4 done.bas problém použití proměnné nazvané DONE https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/done.bas
5 factorial1.bas výpočet faktoriálu v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/factorial1.bas
6 factorial2.bas použití speciálních konstant nabízených Turbo BASICem https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/factorial2.bas
7 function1.bas vykreslení průběhu nespojité funkce https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/function1.bas
8 function2.bas vykreslení průběhu funkce https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/function2.bas
9 game.bas jednoduchá hra naprogramovaná na dvou řádcích https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/game.bas
10 GCD.bas výpočet největšího společného dělitele v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/GCD.bas
31 harmonic.bas zjištění limitů FP hodnot v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/harmonic.bas
32 moire1.bas moaré v grafickém režimu 7 https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/moire1.bas
33 moire2.bas moaré v grafickém režimu 9 https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/moire2.bas
34 moire3.bas moaré v grafickém režimu 11 https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/moire3.bas
35 PI.bas výpočet Pi v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/PI.bas
36 PMG1.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/PMG1.bas
37 PMG2.bas zobrazení spritů https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/PMG2.bas
38 snowcrash.bas simulace „sněhu“ na televizoru bez příjmu signálu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/snowcrash.bas
39 strings.bas zpracování řetězců v Turbo BASICu https://github.com/tisnik/8bit-fame/blob/master/Turbo-Basic%20XL/strings.bas

Příklady pro Microsoft BASIC

# Jméno souboru Stručný popis souboru Cesta
1 strings.bas zpracování řetězců v Microsoft BASICu https://github.com/tisnik/8bit-fame/blob/master/Microsof­t%20BASIC/strings.bas
2 def_func.bas definice funkcí v Microsoft BASICu https://github.com/tisnik/8bit-fame/blob/master/Microsof­t%20BASIC/def_func.bas
3 sort.bas setřídění pole bubble sortem https://github.com/tisnik/8bit-fame/blob/master/Microsof­t%20BASIC/sort.bas
4 sort_int.bas setřídění pole bubble sortem, použití celočíselných indexů https://github.com/tisnik/8bit-fame/blob/master/Microsof­t%20BASIC/sort_int.bas
5 sort_int_int.bas setřídění pole celých čísel bubble sortem, použití celočíselných indexů https://github.com/tisnik/8bit-fame/blob/master/Microsof­t%20BASIC/sort_int_int.bas

Benchmarky

# Jméno souboru Stručný popis souboru Cesta
1 bubble_sort.bas první benchmark: bubble sort https://github.com/tisnik/8bit-fame/blob/master/benchmar­ks/bubble_sort.bas
2 bubble_sort.csv výsledek benchmarku v CSV formátu https://github.com/tisnik/8bit-fame/blob/master/benchmar­ks/bubble_sort.csv
3 bubble_sort.png výsledek benchmarku ve formě sloupcového grafu https://github.com/tisnik/8bit-fame/blob/master/benchmar­ks/bubble_sort.png
       
4 snowcrash.bas druhý benchmark: vykreslení šumu na obrazovku https://github.com/tisnik/8bit-fame/blob/master/benchmar­ks/snowcrash.bas
5 snowcrash.csv výsledek benchmarku v CSV formátu https://github.com/tisnik/8bit-fame/blob/master/benchmar­ks/snowcrash.csv
6 snowcrash.png výsledek benchmarku ve formě sloupcového grafu https://github.com/tisnik/8bit-fame/blob/master/benchmar­ks/snowcrash.png
       
7 plot_benchmark_results.py skript pro vykreslení grafů s výsledkem benchmarků https://github.com/tisnik/8bit-fame/blob/master/benchmar­ks/plot_benchmark_results­.py

20. Odkazy na Internetu

  1. Sedmdesátiny assemblerů: lidsky čitelný strojový kód
    https://www.root.cz/clanky/sed­mdesatiny-assembleru-lidsky-citelny-strojovy-kod/
  2. Programovací jazyk BASIC na osmibitových mikropočítačích
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-osmibitovych-mikropocitacich/
  3. Programovací jazyk BASIC na osmibitových mikropočítačích (2)
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-osmibitovych-mikropocitacich-2/#k06
  4. Programovací jazyk BASIC na herní konzoli Atari 2600
    https://www.root.cz/clanky/pro­gramovaci-jazyk-basic-na-herni-konzoli-atari-2600/
  5. Stránka magazínu (diskmagu) FLOP
    http://flop.atariportal.cz/
  6. Action (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Action
  7. Assembler (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Assembler
  8. Basic (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Basic
  9. C (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=C
  10. Forth (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Forth
  11. Fortran (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Fortran
  12. Lisp (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Lisp
  13. Logo (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Logo
  14. Pascal (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Pascal
  15. Pilot (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Pilot
  16. PL65 (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=PL65
  17. Quick (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=Quick
  18. WSFN (AtariWiki.org)
    https://atariwiki.org/wiki/Wi­ki.jsp?page=WSFN
  19. MAC/65 (Wikipedia)
    https://en.wikipedia.org/wiki/MAC/65
  20. Atari Assembler Editor
    https://en.wikipedia.org/wi­ki/Atari_Assembler_Editor#A­MAC
  21. cc65
    https://cc65.github.io/
  22. Grafika na osmibitových počítačích firmy Sinclair
    http://www.root.cz/clanky/grafika-na-osmibitovych-pocitacich-firmy-sinclair/
  23. Stránky RetroFestu
    http://retrofest.cz/
  24. RetroHerna
    http://retroherna.cz/
  25. BASIC
    http://cs.wikipedia.org/wiki/BASIC
  26. BASIC
    http://en.wikipedia.org/wiki/BASIC
  27. Rosetta Code – Category Basic
    http://rosettacode.org/wi­ki/Category:BASIC
  28. Dartmouth College Computation Center: 1964 – The original Dartmouth BASIC manual
    http://www.bitsavers.org/pdf/dar­tmouth/BASIC_Oct64.pdf
  29. The Original BASIC
    http://www.truebasic.com/
  30. BASIC – Beginners All-purpose Symbolic Instruction Code
    http://hopl.murdoch.edu.au­/showlanguage.prx?exp=176
  31. Turbo BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Turbo_BASIC
  32. Sinclair BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Sinclair_BASIC
  33. Action!
    https://atari8bitbot.com/action/
  34. Atari Logo
    https://atari8bitbot.com/atari-logo/
  35. Atari PILOT & Super PILOT
    https://atari8bitbot.com/atari-pilot/
  36. Turbo-BASIC XL
    https://atari8bitbot.com/turbo-basic-xl/
  37. Atari Assembler/Editor
    https://atari8bitbot.com/atari-assembler-editor/
  38. Strings in Atari BASIC
    http://www.cyberroach.com/a­nalog/an11/strings.htm
  39. String Arrays in Atari BASIC
    http://www.atarimagazines­.com/compute/issue11/52_1_STRIN­G_ARRAYS_IN_ATARI_BASIC.php
  40. An Atari BASIC Tutorial
    http://www.cyberroach.com/a­nalog/an25/basictutorial.htm
  41. Atari Logo
    https://en.wikipedia.org/wi­ki/Atari_Logo
  42. Computer art and animation : a user's guide to Atari logo
    https://archive.org/detail­s/Computer_Art_and_Animati­on
  43. 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/
  44. Going into Action! with Atari XL/XE – Part 2 – Graphics
    https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-2-graphics/
  45. 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/
  46. 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/
  47. Atari800 (emulátor)
    https://github.com/atari800/atari800
  48. Atari MAC/65 Tutorial
    https://www.youtube.com/wat­ch?v=RyBsGDJBXD0
  49. MAC/65 Manual
    http://www.mixinc.net/atari/mac65.htm
  50. BASIC 10 Liner Contest 2021
    https://atariage.com/forum­s/topic/316645-basic-10-liner-contest-2021/
  51. 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/
  52. Deep Blue C
    https://en.wikipedia.org/wi­ki/Deep_Blue_C
  53. Deep Blue C Compiler
    https://www.atariarchives­.org/APX/showinfo.php?cat=20166
  54. 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/
  55. 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/
  56. 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/
  57. Atari BASIC XL (manuál)
    http://www.atarimania.com/8bit/fi­les/BASIC%20XL%20%C2%A4%20Se­cond%20Edition.pdf
  58. BASIC XE For Atari XL & XE
    https://www.atarimagazines­.com/compute/issue67/318_1_Re­views_BASIC_XE_For_Atari_XL_XE­.php
  59. BUG/65 (Reference manual)
    https://atariwiki.org/wiki/at­tach/Bug65/BUG-65%20Version%202.0%20manual-final%20with%20errorpage.pdf
  60. Cross compiler
    https://en.wikipedia.org/wi­ki/Cross_compiler
  61. 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
  62. ATasm
    https://atari.miribilist.com/atasm/
  63. ATasm v1.09 („Global Pandemic Release“)
    https://atari.miribilist.com/a­tasm/atasm.pdf
  64. DOS XL
    https://en.wikipedia.org/wiki/DOS_XL
  65. Aztec C online Museum
    https://www.clipshop.ca/Az­tec/index.htm
  66. Aztec C Compilers
    http://aztecmuseum.ca/compilers.htm
  67. Scratchbox
    http://scratchbox.org/
  68. 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
  69. PAL/NTSC Upgrade
    https://www.myatari.com/nirdary.html
  70. 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
  71. Atari Microsoft Basic manual
    http://www.atarimania.com/8bit/fi­les/Atari_Microsoft_Basic­.pdf

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.