BASIC na Atari pre začiatočníkov#

Príručka jazyka BASIC pre 8-bitové počítače Atari, písaná pre ľudí, ktorí s Atari ani s BASICom nikdy nerobili a programujú málo alebo vôbec. Programy sa píšu na dnešnom počítači s Windows, preloží ich prekladač Basic26 a bežia na Atari alebo v jeho emulátore.

Každá kapitola vysvetlí jeden príkaz alebo jednu tému a obsahuje celý program, ktorý si môžeš hneď preložiť a spustiť. Všetky programy sú aj hotové v priečinku examples/.

Kniha má tri časti:

• Atari BASIC (kapitoly 1 až 25) – jazyk, ktorý malo každé Atari XL a XE v sebe. Všetko z tejto časti platí aj v Turbo-BASICu XL.
• Turbo-BASIC XL (kapitoly 26 až 38) – rozšírený BASIC Franka Ostrowského z roku 1985: slučky bez GOTO, procedúry, kruhy, vypĺňanie plôch a ďalšie.
• Basic26 (kapitoly 39 až 50) – čo vie prekladač navyše: voľby, diskety, pribalené súbory, pamäť ukrytá pod operačným systémom a v rozšíreniach, kompresia, program bez čísel riadkov, nečitateľný súbor, hráči a strely, rýchle celé čísla.

Ako čítať#

Čítaj od začiatku. Kapitoly sú krátke a každá stavia na predošlých. Program z kapitoly si prelož, spusti a potom v ňom niečo zmeň – časť Vyskúšaj si na konci kapitoly dáva nápady.

Obsah#

Začíname#

Základy jazyka#

Rozhodovanie a opakovanie#

Dáta#

Program a počítač#

Turbo-BASIC XL#

Čo má Basic26 navyše#

Prílohy#

1. Úvod#

Verzia dokumentácie: 1.0.0.208

Čo je Atari#

Atari 800XL a 130XE sú domáce počítače z osemdesiatych rokov. Majú procesor 6502, 64 alebo 128 kilobajtov pamäte a pripájali sa k televízoru. Po zapnutí na nich nebeží žiadny Windows – počítač čaká, kým mu napíšeš program alebo mu ho dáš z kazety, z diskety či zo zásuvného modulu (cartridge).

Dnes tie počítače stále fungujú a kto ich nemá, používa emulátor: program, ktorý sa na dnešnom počítači správa ako Atari.

Čo je BASIC#

BASIC je programovací jazyk vymyslený pre začiatočníkov. Program v ňom sa číta skoro ako anglické vety:

10 PRINT "Hello, Atari!"
20 GOTO 10

Atari XL a XE majú BASIC zabudovaný – volá sa Atari BASIC. Zapneš počítač, na obrazovke sa objaví READY a môžeš písať. Tisíce programov a hier z časopisov tých čias sú napísané v ňom.

BASIC na Atari je interpreter: program číta riadok po riadku a každý riadok zakaždým znova lúšti. Je to pohodlné, ale pomalé.

Čo je Turbo-BASIC XL#

V roku 1985 napísal Frank Ostrowski Turbo-BASIC XL. Rozumie všetkému, čo Atari BASIC, je niekoľkokrát rýchlejší a pridáva desiatky príkazov: slučky WHILE a REPEAT, procedúry, kreslenie kruhov, vypĺňanie plôch. Nahrával sa z diskety.

Prvé dve tretiny tejto knihy vystačia s Atari BASICom. Turbo-BASIC XL príde na rad v kapitole 26.

Čo je Basic26#

Basic26 je prekladač oboch jazykov, ktorý beží na počítači s Windows.

• Program píšeš v ľubovoľnom textovom editore (Poznámkový blok, Visual Studio Code, Sublime Text …).
• Basic26 ho preloží za zlomok sekundy.
• Výsledok je súbor, ktorý sa dá spustiť na Atari alebo v emulátore – bez BASICu, bez Turbo-BASICu, sám.

Preložený program robí to isté, čo by s tým istým textom robil interpreter: vypíše tie isté čísla, nakreslí tie isté obrázky, ohlási tie isté chyby. Len beží rýchlejšie. Prekladač vie prečítať aj staré programy z diskiet (kapitola 41).

Niekoľko slov, ktoré budeš stretávať#

Ďalšie slová vysvetlí kniha vtedy, keď ich bude treba. Všetky sú v slovníčku.

Čo potrebuješ#

1. Počítač s Windows 10 alebo 11.
2. Súbor Basic26.exe. Je to jeden súbor, nič sa neinštaluje. Skopíruj si ho do priečinka, kde budeš mať svoje programy, alebo do priečinka, ktorý máš v systémovej ceste (PATH) – potom ho môžeš volať odkiaľkoľvek.
3. Súbor ATARIXL.ROM v priečinku atari800 vedľa Basic26.exe. Je to kópia programov, ktoré má Atari v sebe; simulátor z nej berie počítanie s číslami. Keď ho nemáš, vezme altirraos-xl.rom, ktorý je pri Basic26.exe – voľne šíriteľnú náhradu od autora emulátora Altirra; počíta takmer rovnako, len niekedy sa líši v poslednej číslici, a prekladač ťa na to upozorní.
4. Textový editor. Stačí Poznámkový blok. Pohodlnejší je editor, ktorý ukazuje čísla riadkov a stĺpcov, lebo prekladač nimi hlási chyby.
5. Príkazový riadok – okno, do ktorého sa píšu príkazy. Vo Windows je to Terminál alebo PowerShell (nájdeš ho v ponuke Štart).

Na kapitoly o grafike, zvuku a joysticku navyše:

6. Emulátor atari800 (atari800.exe) v tom istom priečinku atari800. Do kapitoly 19 sa bez neho zaobídeš.

Skúška, či všetko funguje#

Otvor príkazový riadok a napíš:

Basic26 --version

Mal by odpovedať štyrmi riadkami, napríklad:

Basic26 1.0.0.150
Atari BASIC and Turbo-BASIC XL cross compiler for Atari 8-bit (XEX)
Copyright (C) 2026 Pedro. MIT License.
Built from main 00f00945163050e23e1f460beedab775a5ecf909

Ak namiesto toho príde hlásenie, že príkaz Basic26 nie je známy, príkazový riadok nevie, kde Basic26.exe leží. Najjednoduchšia náprava: prejdi v príkazovom riadku do priečinka, kde ten súbor máš, a píš .\Basic26 namiesto Basic26.

cd C:\Atari

.\Basic26 --version

Ako je kniha usporiadaná#

Každá kapitola má tie isté časti:

• Na čo to je – o čom príkaz je, jednou vetou.
• Ako sa to píše – tvar príkazu.
• Celý program – nie úryvok; dá sa preložiť tak, ako je.
• Preklad a spustenie – príkaz, ktorý stačí skopírovať.
• Čo uvidíš – skutočný výpis programu.
• Ako to funguje – program riadok po riadku.
• Časté chyby – čo sa pokazí najčastejšie a čo na to povie prekladač.
• Vyskúšaj si – malé úlohy.
• Zhrnutie.

Všetky programy sú hotové v priečinku examples/. Texty, ktoré programy vypisujú, sú po anglicky: Atari nemá slovenské písmená s dĺžňami a mäkčeňmi.

Ďalej: 2. Prvý program

2. Prvý program#

Na čo to je#

Prejdeš celú cestu od prázdneho súboru po bežiaci program: napísať, uložiť, preložiť, spustiť. Všetky ďalšie kapitoly robia to isté, len s inými príkazmi.

Celý program#

Otvor textový editor a napíš (alebo si otvor hotový súbor examples/hello.abas):

10 REM My first program in BASIC
20 PRINT "Hello, Atari!"

Ulož ho ako hello.abas. Prípona .abas hovorí, že je to zdroják v Atari BASICu.

Pozor pri ukladaní z Poznámkového bloku: v okne Uložiť ako zvoľ typ Všetky súbory, inak sa súbor uloží ako hello.abas.txt.

Preklad a spustenie#

V príkazovom riadku prejdi do priečinka, kde súbor leží, a napíš:

Basic26 hello.abas --sim

Prekladač program preloží a voľba --sim ho hneď spustí vo vstavanom simulátore.

Čo uvidíš#

Hello, Atari!

To je všetko, čo program robí: vypíše jeden riadok a skončí.

Ako to funguje#

Program v BASICu sa skladá z riadkov a každý riadok sa začína číslom. Počítač ich vykonáva od najmenšieho čísla po najväčšie.

10 REM My first program in BASIC

REM (z anglického remark, poznámka) je komentár. Všetko za ním až do konca riadka počítač preskočí. Je to poznámka pre človeka.

20 PRINT "Hello, Atari!"

PRINT vypíše na obrazovku to, čo za ním nasleduje, a prejde na nový riadok. Text sa píše do úvodzoviek.

Za posledným riadkom program skončí sám.

Prečo 10 a 20, a nie 1 a 2#

Na skutočnom Atari sa program písal rovno do počítača a riadok sa nedal „vsunúť“ medzi dva iné – jeho miesto určovalo číslo. Preto sa čísluje po desiatich: keď neskôr zistíš, že medzi riadky 10 a 20 treba ešte niečo, dáš tomu číslo 15.

V textovom editore riadok vsunieš, kam chceš, ale číslo mu dať musíš aj tak – a prekladač riadky zoradí podľa čísel, nie podľa poradia v súbore. Číslo môže byť od 0 do 32767.

Čo vzniklo na disku#

Po preklade pribudol vedľa zdrojáka súbor hello.xex. To je hotový program pre Atari – má 1005 bajtov. Dá sa skopírovať na disketu alebo spustiť v emulátore.

Keď chceš program len preložiť a nespúšťať, voľbu --sim vynechaj:

Basic26 hello.abas

Keď sa preklad podarí, prekladač nevypíše nič. Ticho znamená „v poriadku“.

Spustenie v emulátore#

Simulátor ukáže len to, čo program vypíše. Emulátor ukáže celé Atari – modrú obrazovku, písmo, farby. Ak ho máš (priečinok atari800 vedľa Basic26.exe), spustíš program takto:

Basic26 hello.abas --run

Otvorí sa okno emulátora a v ňom tvoj text. Keď program skončí, obrazovka ostane tak, ako ju nechal; emulátor zavrieš klávesom F9 alebo krížikom okna.

Keď prekladač nájde chybu#

Chyby sú pri programovaní bežné. Skús úmyselne jednu spraviť: namiesto PRINT napíš PRIT.

10 REM My first program in BASIC
20 PRIT "Hello, Atari!"

Prekladač odpovie:

hello.abas(2,9): error B26017: expected '=' after a string

Každé hlásenie má štyri časti:

Popis tu na prvý pohľad nesedí – veď chýba písmeno, nie rovná sa. Prekladač však slovo PRIT nepozná, a tak si myslí, že je to meno premennej, do ktorej chceš niečo uložiť (o tom je kapitola 4); za takým menom čaká znak =. Z toho plynú dve rady:

• Opravuj vždy prvú chybu. Ďalšie sú často len jej následkom.
• Chyba je na označenom mieste alebo tesne pred ním. Prekladač si ju všimne, až keď mu prestane dávať zmysel to, čo číta.

Kým má program chybu (error), súbor .xex nevznikne a nič sa nespustí. Upozornenie (warning) preklad nezastaví.

Časté chyby#

Príkazy Atari BASICu sa píšu veľkými písmenami. Malé písmená smú byť len v texte v úvodzovkách a za REM. Turbo-BASIC XL malé písmená berie (kapitola 26).

Vyskúšaj si#

1. Zmeň text v úvodzovkách na svoje meno a program znova prelož a spusti.
2. Pridaj riadok 30 PRINT "…" s iným textom.
3. Pridaj riadok s číslom 15 na koniec súboru, až za riadok 30, a pozri, kedy sa vypíše. Prekladač na to upozorní hlásením warning B26230.

Zhrnutie#

• Program je textový súbor s príponou .abas; každý riadok sa začína číslom.
• Riadky sa vykonávajú podľa čísel, od najmenšieho.
• Basic26 meno.abas ho preloží do meno.xex; --sim ho hneď spustí v simulátore, --run v emulátore.
• PRINT "text" vypíše riadok textu, REM je komentár.
• Príkazy sa píšu veľkými písmenami.
• Chybové hlásenie hovorí súbor, riadok, stĺpec a dôvod. Opravuj od prvého.

Späť: 1. Úvod · Ďalej: 3. Výpis

3. Výpis: PRINT, REM, END#

Na čo to je#

PRINT je najpoužívanejší príkaz BASICu: vypíše na obrazovku text, číslo alebo výsledok výpočtu. V tejto kapitole k nemu pribudnú tri drobnosti, bez ktorých sa žiadny program nezaobíde: komentár REM, dvojbodka medzi príkazmi a END.

Ako sa to píše#

PRINT čo;čo,čo

A k tomu:

Celý program#

Súbor examples/print.abas:

10 REM PRINT: writing on the screen
20 PRINT "One line"
30 PRINT "Two ";"parts ";"joined"
40 PRINT "Left","Right"
50 PRINT 5
60 PRINT "Five plus three is ";5+3
70 PRINT
80 PRINT "No new line: ";
90 PRINT "it goes on here"
100 ? "A question mark is PRINT too"
110 PRINT "One":PRINT "Two":REM two statements on a line
120 END
130 PRINT "Never printed"

Preklad a spustenie#

Basic26 print.abas --sim

Čo uvidíš#

One line
Two parts joined
Left      Right
5
Five plus three is 8

No new line: it goes on here
A question mark is PRINT too
One
Two

Ako to funguje#

• Riadok 30: bodkočiarka lepí veci tesne za seba. Medzery medzi slovami sú preto vo vnútri úvodzoviek ("Two "), BASIC žiadne nepridá.
• Riadok 40: čiarka posunie výpis na ďalšiu zarážku. Zarážky sú po desiatich znakoch, takže Right sa začína na jedenástom mieste. Hodí sa to na jednoduché tabuľky.
• Riadok 50: číslo sa píše bez úvodzoviek. PRINT 5 vypíše číslo 5, PRINT "5" vypíše znak 5 – na obrazovke vyzerajú rovnako, ale len s prvým sa dá počítať.
• Riadok 60: text a výpočet v jednom príkaze. BASIC najprv vypočíta 5+3 a vypíše výsledok.
• Riadky 80 a 90: bodkočiarka na konci drží kurzor na riadku, ďalší PRINT pokračuje tam, kde prvý skončil.
• Riadok 110: tri príkazy na jednom riadku. Za REM je však komentárom všetko až do konca riadka, aj dvojbodka a čokoľvek za ňou – REM teda musí byť na riadku posledný.
• Riadok 120: END program ukončí. Riadok 130 sa už nevykoná. Na konci programu END písať nemusíš; hodí sa, keď za hlavnou časťou programu nasleduje ešte niečo, kam program nemá „dobehnúť“ (kapitola 11).

Časté chyby#

Vyskúšaj si#

1. Vypíš tri mená pod seba, potom tie isté tri mená na jeden riadok oddelené čiarkou a medzerou.
2. Vypíš malú tabuľku s dvoma stĺpcami pomocou čiarky: v prvom mená, v druhom čísla.
3. Čo vypíše PRINT "2+2" a čo PRINT 2+2? Najprv si tipni, potom vyskúšaj.

Zhrnutie#

• PRINT vypíše texty v úvodzovkách a čísla alebo výpočty bez nich.
• Bodkočiarka lepí, čiarka posúva na ďalšiu zarážku; na konci príkazu zabránia novému riadku.
• ? je to isté ako PRINT.
• REM je komentár do konca riadka, : oddeľuje príkazy, END končí program.

Späť: 2. Prvý program · Ďalej: 4. Premenné a čísla

4. Premenné a čísla: LET#

Na čo to je#

Premenná je pomenované miesto v pamäti, do ktorého si program odloží číslo, aby ho mohol neskôr použiť alebo zmeniť. Predstav si škatuľku s menovkou: APPLES a v nej číslo 5.

Ako sa to píše#

LET meno=hodnota
meno=hodnota

Premennú netreba vopred ohlasovať. Vznikne tým, že ju použiješ, a kým do nej nič neuložíš, je v nej nula.

Celý program#

Súbor examples/variables.abas:

10 REM Variables: boxes with a name
20 LET APPLES=5
30 PRICE=0.25
40 PRINT "Apples: ";APPLES
50 PRINT "Price of one: ";PRICE
60 COST=APPLES*PRICE
70 PRINT "Together: ";COST
80 APPLES=APPLES+1
90 PRINT "One more apple: ";APPLES
100 BIG=1500000000000
110 PRINT BIG
120 THIRD=1/3
130 PRINT THIRD
140 PRINT EMPTY

Preklad a spustenie#

Basic26 variables.abas --sim

Čo uvidíš#

Apples: 5
Price of one: 0.25
Together: 1.25
One more apple: 6
1.5E+12
0.333333333
0

Ako to funguje#

• Riadky 20 a 30: to isté dvoma spôsobmi, s LET a bez neho. Desatinné číslo sa píše s bodkou, nie s čiarkou.
• Riadok 60: vpravo je výpočet. BASIC vezme, čo je práve v APPLES a PRICE, vynásobí to (* je krát) a výsledok uloží do COST.
• Riadok 80: APPLES=APPLES+1 nie je rovnica – tá by nemala riešenie. Je to príkaz: „zober, čo je v APPLES, pripočítaj 1 a ulož späť do APPLES“. Takto sa v programoch počíta.
• Riadok 110: veľmi veľké a veľmi malé čísla vypisuje BASIC skrátene. 1.5E+12 znamená 1,5 krát desať na dvanástu, teda 1,5 a dvanásť miest doprava. Rovnako ich môžeš aj písať: BIG=1.5E12.
• Riadok 130: jedna tretina má nekonečne veľa trojok, ale Atari si pamätá len desať číslic (a Atari BASIC ich vypíše deväť). Na bežné počítanie to stačí; pri peniazoch a dlhých výpočtoch sa občas na poslednom mieste objaví drobná odchýlka.
• Riadok 140: do EMPTY nikto nič neuložil, je v nej nula.

Čísla môžu byť od približne 1E-98 po 9.99999999E+97, kladné aj záporné.

Na mene záleží#

Meno môže byť dlhé, ale nesmie sa začínať slovom, ktoré BASIC pozná ako príkaz. Atari BASIC totiž medzery nepotrebuje – PRINTX číta ako PRINT X. Preto:

10 LETTER=4
20 PRINT LETTER

vypíše 0. Riadok 10 sa prečíta ako LET TER=4, takže štvorka skončí v premennej TER, a riadok 20 vypíše inú, prázdnu premennú LETTER. Program je správny, len robí niečo iné, než si chcel. Prekladač na to upozorní, lebo meno LETTER program inde používa:

warning B26236: LETTER is read as LET TER here, as the interpreter reads it: a statement begins with the statement word its text begins with, and LETTER elsewhere in the program is another variable

Väčšinou sa však na také meno príde hneď, lebo zvyšok riadka prestane dávať zmysel:

Meno sa teda nesmie začínať slovom, ktorým sa môže začínať príkaz (LET, ON, FOR, IF, END, REM, DIM, RUN, GET, PUT, POP, NEW, DOS, BYE … – všetky sú v prílohe A). Uprostred mena slovo nevadí (COST, SCORE, TOTAL sú v poriadku).

Zvláštny prípad je slovo NOT (kapitola 8). Na začiatku príkazu sa meno s NOT na začiatku berie ako meno, ale vo výpočte ho BASIC rozdelí:

10 NOTHING=5
20 PRINT NOTHING

vypíše 1. Riadok 10 uloží päťku do premennej NOTHING; riadok 20 sa však číta ako PRINT NOT HING – „opak“ prázdnej premennej HING, teda 1. K svojej päťke sa už nedostaneš. Tak to robia oba interpretery a tak to preloží aj Basic26, s upozornením:

warning B26230: NOTHING is read as NOT HING here, as the interpreter reads it: a name that begins with NOT is one only where a value is stored

Keď program počíta čudne, podozrievaj najprv meno.

Dobové programy mávajú premenné s jedným-dvoma písmenami (A, X1, SC). Šetrilo to pamäť. V programe pre prekladač si pokojne dovoľ meno, ktoré niečo hovorí.

Časté chyby#

Atari BASIC unesie v jednom programe najviac 128 rôznych premenných.

Vyskúšaj si#

1. Pridaj premennú PEARS s počtom hrušiek a vypíš, koľko je ovocia spolu.
2. Zmeň cenu na 0.3 a pozri, čo vyjde. Potom skús PRICE=1/3.
3. Vymeň hodnoty dvoch premenných A a B. (Budeš potrebovať tretiu, pomocnú.)

Zhrnutie#

• Premenná je pomenované miesto na číslo; vznikne použitím a začína s nulou.
• meno=výpočet vypočíta pravú stranu a uloží ju; LET je nepovinné.
• A=A+1 zväčší premennú o jedna.
• Desatinné čísla sa píšu s bodkou; Atari počíta na desať číslic.
• Meno sa nesmie začínať slovom BASICu.

Späť: 3. Výpis · Ďalej: 5. Počítanie

5. Počítanie: + - * / ^, INT, ABS, SGN, SQR#

Na čo to je#

BASIC je aj kalkulačka. Všade, kde môže stáť číslo, môže stáť výraz – výpočet z čísel, premenných, znamienok a funkcií.

Ako sa to píše#

Funkcia je hotový výpočet s menom. Číslo, s ktorým má počítať, sa píše za ňu do zátvoriek:

Celý program#

Súbor examples/expr.abas:

10 REM Arithmetic
20 PRINT "7+3 = ";7+3
30 PRINT "7-3 = ";7-3
40 PRINT "7*3 = ";7*3
50 PRINT "7/3 = ";7/3
60 PRINT "7^2 = ";7^2
70 PRINT "2+3*4 = ";2+3*4
80 PRINT "(2+3)*4 = ";(2+3)*4
90 PRINT "INT(7/3) = ";INT(7/3)
100 PRINT "INT(-2.5) = ";INT(-2.5)
110 PRINT "ABS(-8) = ";ABS(-8)
120 PRINT "SGN(-8) = ";SGN(-8)
130 PRINT "SQR(16) = ";SQR(16)
140 REM The remainder after dividing 17 by 5
150 A=17:B=5
160 PRINT "17 = ";INT(A/B);"*5 + ";A-INT(A/B)*B
170 REM Rounding to two decimal places
180 X=3.14159
190 PRINT INT(X*100+0.5)/100

Preklad a spustenie#

Basic26 expr.abas --sim

Čo uvidíš#

7+3 = 10
7-3 = 4
7*3 = 21
7/3 = 2.33333333
7^2 = 49
2+3*4 = 14
(2+3)*4 = 20
INT(7/3) = 2
INT(-2.5) = -3
ABS(-8) = 8
SGN(-8) = -1
SQR(16) = 4
17 = 3*5 + 2
3.14

Ako to funguje#

Poradie počítania#

Riadok 70 dá 14, nie 20: BASIC počíta ako v škole, násobenie a delenie pred sčítaním a odčítaním. Celé poradie:

1. zátvorky,
2. umocnenie ^,
3. násobenie a delenie * /,
4. sčítanie a odčítanie + -.

Rovnako silné znamienka sa počítajú zľava doprava: 10/4*2 je (10/4)*2, teda 5. Keď si nie si istý, daj zátvorky – nič nestoja a program je čitateľnejší.

Delenie nie je celé#

7/3 je 2.33333333. BASIC na Atari nemá zvláštne „celé čísla“, každé číslo môže mať desatinnú časť. Keď chceš celý podiel, odrež zvyšok funkciou INT.

INT ide nadol, nie k nule#

INT(2.7) je 2, ale INT(-2.5) je -3: najbližšie celé číslo, ktoré je menšie. Pri kladných číslach je to to isté ako „odrezať desatinnú časť“, pri záporných nie.

Dva užitočné triky s INT#

• Zvyšok po delení (riadok 160): A-INT(A/B)*B. Sedemnásť delené piatimi je 3 a zvyšok 2. Zvyškom sa zisťuje, či je číslo párne (N-INT(N/2)*2 je 0), a robí sa ním všetko, čo sa má „točiť dokola“.
• Zaokrúhlenie (riadok 190): INT(X+0.5) zaokrúhli na celé číslo. Na dve desatinné miesta sa číslo najprv vynásobí stomi, zaokrúhli a zasa vydelí.

Časté chyby#

ERROR- s číslom je chyba za behu: program sa preložil, ale počas behu narazil na niečo, čo sa vypočítať nedá. Vypíše číslo chyby a riadok programu, na ktorom sa stala, a skončí. Čísla sú v prílohe C; kapitola 17 ukáže, ako chybu zachytiť.

Vyskúšaj si#

1. Vypočítaj, koľko sekúnd má deň a koľko rok.
2. Obdĺžnik má strany A a B. Vypíš jeho obvod, obsah a dĺžku uhlopriečky (SQR(A*A+B*B)).
3. Rozmeň 187 sekúnd na minúty a sekundy pomocou INT a zvyšku.

Zhrnutie#

• + - * / ^ a zátvorky; násobenie a delenie majú prednosť pred sčítaním a odčítaním.
• Delenie dáva desatinné číslo; INT ho oreže nadol.
• Zvyšok po delení je A-INT(A/B)*B, zaokrúhlenie INT(X+0.5).
• Funkcia má svoje číslo v zátvorkách: SQR(16), ABS(-8).
• Čo sa vypočítať nedá, skončí chybou za behu: ERROR- a číslo.

Späť: 4. Premenné a čísla · Ďalej: 6. Reťazce

6. Reťazce: DIM, LEN, A$(i,j)#

Na čo to je#

Reťazec je premenná, ktorá nedrží číslo, ale text: meno, slovo, celú vetu. Spoznáš ju podľa znaku dolára na konci mena: NAME$.

Ako sa to píše#

DIM meno$(dĺžka)
meno$="text"

Na rozdiel od čísla treba reťazec vopred ohlásiť príkazom DIM (z anglického dimension, rozmer). Počítač mu musí vyhradiť miesto a potrebuje vedieť koľko. Jeden DIM môže ohlásiť viac reťazcov, oddelených čiarkou.

Celý program#

Súbor examples/strings.abas:

10 REM Strings: variables that hold text
20 DIM NAME$(20),GREETING$(40)
30 NAME$="Atari"
40 PRINT NAME$
50 PRINT "Length: ";LEN(NAME$)
60 PRINT "First letter: ";NAME$(1,1)
70 PRINT "Letters 2 to 4: ";NAME$(2,4)
80 PRINT "From the 3rd on: ";NAME$(3)
90 GREETING$="Hello, "
100 GREETING$(LEN(GREETING$)+1)=NAME$
110 PRINT GREETING$
120 NAME$(1,1)="a"
130 PRINT NAME$
140 DIM SHORT$(3)
150 SHORT$="ABCDEFGH"
160 PRINT SHORT$

Preklad a spustenie#

Basic26 strings.abas --sim

Čo uvidíš#

Atari
Length: 5
First letter: A
Letters 2 to 4: tar
From the 3rd on: ari
Hello, Atari
atari
ABC

Ako to funguje#

• Riadok 20: NAME$ má miesto na 20 znakov, GREETING$ na 40. To je najviac; koľko znakov v reťazci naozaj je, závisí od toho, čo doň uložíš. Hneď po DIM je prázdny a LEN je 0.
• Riadok 50: v NAME$ je päť znakov, hoci miesta je na dvadsať.
• Riadky 60 až 80: znaky sa číslujú od jednotky. NAME$(2,4) je druhý až štvrtý znak. S jedným číslom ide časť až do konca.
• Riadok 100: Atari BASIC nemá znamienko na spájanie textov. Spája sa tak, že druhý text zapíšeš za koniec prvého: GREETING$ má 7 znakov, zápis začína na ôsmom mieste.
• Riadok 120: zápis do časti reťazca prepíše len tú časť – tu prvé písmeno.
• Riadky 140 až 160: do reťazca sa zmestí len toľko, koľko povolil DIM. Zvyšok sa bez hlásenia odreže: z ôsmich písmen ostali tri.

Časté chyby#

A$ a A sú dve rôzne premenné: jedna na text, druhá na číslo. Môžu existovať naraz.

Pozor na pascu pri spájaní: A$(LEN(A$)+1)=B$ zapisuje za koniec A$. Ak je A$ už plný po DIM, zápis je mimo a program skončí chybou 5.

Vyskúšaj si#

1. Ulož do reťazca svoje meno a vypíš jeho posledné písmeno. (Je na mieste LEN(NAME$).)
2. Zlož z dvoch reťazcov, mena a priezviska, tretí s medzerou medzi nimi.
3. Vypíš prvé tri písmená slova, potom posledné tri.

Zhrnutie#

• Reťazec má meno s $ a pred použitím potrebuje DIM meno$(najviac znakov).
• LEN(A$) je počet znakov, ktoré v ňom práve sú.
• A$(i,j) je časť od i-teho po j-ty znak, A$(i) od i-teho do konca; počíta sa od 1.
• Spája sa zápisom za koniec: A$(LEN(A$)+1)=B$.
• Čo sa nezmestí, sa ticho odreže.

Späť: 5. Počítanie · Ďalej: 7. Vstup

7. Vstup: INPUT#

Na čo to je#

Doteraz boli všetky čísla a texty napísané v programe. S INPUT sa program spýta – počká, kým človek niečo napíše a stlačí RETURN, a to, čo napísal, uloží do premennej.

Ako sa to píše#

INPUT premenná
INPUT premenná,premenná

INPUT vypíše len otáznik. O čo ide, musí povedať PRINT pred ním – s bodkočiarkou na konci, aby otáznik ostal na tom istom riadku.

Celý program#

Súbor examples/input.abas:

10 REM INPUT: the program asks
20 DIM NAME$(20)
30 PRINT "What is your name";
40 INPUT NAME$
50 PRINT "How old are you";
60 INPUT AGE
70 PRINT "Hello, ";NAME$;"!"
80 PRINT "Next year you will be ";AGE+1
90 PRINT "Give me two numbers"
100 INPUT A,B
110 PRINT A;" + ";B;" = ";A+B

Preklad a spustenie#

Tento program potrebuje klávesnicu, a tú simulátor nemá. Sú dve možnosti.

V emulátore píšeš odpovede sám, na klávesnici Atari:

Basic26 input.abas --run

V simulátore dostane program odpovede zo súboru. Súbor examples/input.in má tri riadky – na každý INPUT jeden:

Peter
12
3,4

Basic26 input.abas --sim --sim-input input.in

Čo uvidíš#

What is your name?Peter
How old are you?12
Hello, Peter!
Next year you will be 13
Give me two numbers
?3,4
3 + 4 = 7

Ako to funguje#

• Riadky 30 a 40: PRINT s bodkočiarkou na konci nechá kurzor za textom, INPUT zaň pripíše otáznik a čaká. Preto v texte otázky otáznik nie je.
• Riadok 40: do NAME$ sa uloží celý riadok, ktorý človek napísal – aj s medzerami a čiarkami. Ak je dlhší než DIM, odreže sa.
• Riadok 60: AGE je číselná premenná, takže INPUT čaká číslo. S číslom z klávesnice sa dá hneď počítať (riadok 80).
• Riadok 100: dve premenné v jednom INPUT. Človek napíše 3,4 a RETURN; môže však napísať aj len 3, stlačiť RETURN, a program sa na druhé číslo spýta ďalším otáznikom.

Časté chyby#

Chyba 8 je nepríjemná: stačí preklep pri písaní a program skončí. Kapitola 17 ukáže, ako ju zachytiť a spýtať sa znova.

Turbo-BASIC XL vie otázku napísať rovno v INPUT (INPUT "Name";N$, kapitola 26). Atari BASIC to nevie.

Vyskúšaj si#

1. Spýtaj sa na dve strany obdĺžnika a vypíš jeho obsah.
2. Spýtaj sa na meno a vypíš, koľko má písmen.
3. Spýtaj sa na rok narodenia a vypíš vek. Uprav si input.in alebo program spusti v emulátore.

Zhrnutie#

• INPUT premenná počká na riadok z klávesnice a uloží ho.
• Do číselnej premennej musí prísť číslo, inak je to chyba 8.
• Otázku vypíše PRINT "…"; pred ním.
• V simulátore dáva odpovede súbor: --sim-input súbor, riadok na každý INPUT.

Späť: 6. Reťazce · Ďalej: 8. Podmienka

8. Podmienka: IF, THEN, AND, OR, NOT#

Na čo to je#

Program, ktorý robí vždy to isté, je nudný. IF mu dáva možnosť rozhodnúť sa: niečo vykoná, len keď platí podmienka.

Ako sa to píše#

IF podmienka THEN príkazy
IF podmienka THEN číslo riadka

Keď podmienka neplatí, program pokračuje ďalším riadkom.

Porovnania:

Podmienky sa dajú spájať:

Celý program#

Súbor examples/if.abas:

10 REM IF: deciding
20 DIM ANSWER$(10)
30 PRINT "How old are you";
40 INPUT AGE
50 IF AGE<0 THEN PRINT "That cannot be":END
60 IF AGE<18 THEN PRINT "You are a child"
70 IF AGE>=18 THEN PRINT "You are an adult"
80 IF AGE>=13 AND AGE<=19 THEN PRINT "You are a teenager"
90 IF AGE=7 OR AGE=77 THEN PRINT "A lucky number!"
100 IF NOT (AGE=100) THEN PRINT "Not a hundred yet"
110 PRINT "Do you like BASIC";
120 INPUT ANSWER$
130 IF ANSWER$="YES" THEN PRINT "So do I"
140 IF ANSWER$<>"YES" THEN PRINT "You will"
150 PRINT "13<18 is ";13<18;", 13>18 is ";13>18

Preklad a spustenie#

V emulátore, s vlastnými odpoveďami:

Basic26 if.abas --run

V simulátore s odpoveďami zo súboru examples/if.in (15 a YES):

Basic26 if.abas --sim --sim-input if.in

Čo uvidíš#

How old are you?15
You are a child
You are a teenager
Not a hundred yet
Do you like BASIC?YES
So do I
13<18 is 1, 13>18 is 0

Ako to funguje#

• Riadok 50: za THEN sú dva príkazy oddelené dvojbodkou. Oba patria k podmienke – keď vek nie je záporný, nevykoná sa ani PRINT, ani END. To je dôležité pravidlo: IF rozhoduje o celom zvyšku riadka.
• Riadky 60 a 70: Atari BASIC nemá „inak“ (ELSE). Opačný prípad sa napíše ako druhý IF s opačnou podmienkou. (Turbo-BASIC XL ELSE má, kapitola 27.)
• Riadok 80: AND – musia platiť obe podmienky. Pozor: nedá sa napísať 13<=AGE<=19 ako v matematike, každé porovnanie musí byť celé.
• Riadok 90: OR – stačí jedna.
• Riadok 100: NOT obráti odpoveď. Porovnanie za ním daj do zátvorky: v Atari BASICu sa NOT viaže len na to, čo stojí tesne za ním, takže NOT AGE=100 by znamenalo (NOT AGE)=100.
• Riadky 130 a 140: reťazce sa porovnávajú rovnako ako čísla. Rovnajú sa, len keď sú rovnaké znak po znaku – "YES" a "yes" sú rôzne.
• Riadok 150: podmienka je pre BASIC tiež číslo: 1, keď platí, a 0, keď neplatí. A naopak, IF berie každé nenulové číslo ako „platí“ – IF A THEN … znamená „ak A nie je nula“.

Reťazce sa dajú porovnávať aj na menší a väčší; rozhoduje poradie znakov v tabuľke Atari, kde sú veľké písmená pred malými. "B"<"C" platí a "abc">"ABC" tiež.

Časté chyby#

Vyskúšaj si#

1. Spýtaj sa na číslo a vypíš, či je kladné, záporné alebo nula.
2. Spýtaj sa na číslo a vypíš, či je párne. (Zvyšok po delení dvoma je v kapitole 5.)
3. Spýtaj sa na heslo a vypíš Welcome, len keď sedí.

Zhrnutie#

• IF podmienka THEN príkazy vykoná zvyšok riadka, len keď podmienka platí.
• Porovnania: = <> < > <= >=, pre čísla aj reťazce.
• AND – obe, OR – aspoň jedna, NOT – naopak (so zátvorkou).
• Platí je 1, neplatí je 0.
• „Inak“ sa v Atari BASICu píše druhým IF s opačnou podmienkou.

Späť: 7. Vstup · Ďalej: 9. Skok

9. Skok: GOTO#

Na čo to je#

Program beží po riadkoch zhora nadol. GOTO (anglicky go to, „choď na“) toto poradie poruší: prikáže pokračovať na inom riadku. Skokom dozadu vznikne opakovanie, skokom dopredu sa kus programu preskočí.

Ako sa to píše#

GOTO číslo riadka

Dá sa písať aj oddelene, GO TO 100. Spolu s IF je to všetko, čo treba na ľubovoľne zložitý program:

IF podmienka THEN GOTO 100
IF podmienka THEN 100

Druhý tvar je skratka prvého.

Celý program#

Súbor examples/goto.abas vypisuje mocniny dvojky, kým neprekročia tisíc:

10 REM GOTO: jumping to another line
20 N=1
30 PRINT N;" ";
40 N=N*2
50 IF N>1000 THEN GOTO 70
60 GOTO 30
70 PRINT
80 PRINT "Done, N is ";N

Preklad a spustenie#

Basic26 goto.abas --sim

Čo uvidíš#

1 2 4 8 16 32 64 128 256 512 
Done, N is 1024

Ako to funguje#

• Riadky 30 až 60 sa opakujú. Riadok 60 posiela program späť na riadok 30 – to je slučka.
• Riadok 50 je východ zo slučky: keď N prekročí tisíc, skočí sa dopredu na riadok 70, za slučku.
• Keby riadok 50 chýbal, program by sa točil donekonečna. Na Atari sa taký program zastaví klávesom BREAK; simulátor sa po desiatich miliónoch krokov vzdá sám.

Druhý program: hádaj číslo#

S INPUT, IF a GOTO sa už dá napísať hra. Súbor examples/guess.abas:

10 REM A guessing game with IF and GOTO
20 SECRET=37:TRIES=0
30 PRINT "Guess my number (1-100)";
40 INPUT G
50 TRIES=TRIES+1
60 IF G<SECRET THEN PRINT "Too small":GOTO 30
70 IF G>SECRET THEN PRINT "Too big":GOTO 30
80 PRINT "Yes! It took you ";TRIES;" tries"

Basic26 guess.abas --run

alebo s odpoveďami zo súboru examples/guess.in:

Basic26 guess.abas --sim --sim-input guess.in

Guess my number (1-100)?50
Too big
Guess my number (1-100)?25
Too small
Guess my number (1-100)?37
Yes! It took you 3 tries

Riadky 60 a 70 sú typický tvar: „ak niečo nesedí, povedz to a choď späť“. Na riadok 80 sa program dostane, len keď neplatí ani jedno – číslo je uhádnuté. Tajné číslo je zatiaľ vždy 37; náhodné príde v kapitole 16.

Prečo s GOTO šetriť#

GOTO je silný a ľahko sa ním spraví neporiadok. Program, v ktorom sa skáče krížom-krážom, sa nedá čítať – hovorí sa mu „špagetový“. Niekoľko zvykov, ktoré pomáhajú:

• Na opakovanie so známym počtom použi FOR (kapitola 10).
• Skákaj dozadu len na začiatok slučky a dopredu len za jej koniec.
• Cieľ skoku označ komentárom: 500 REM Game over.

V Turbo-BASICu XL sa dá väčšina GOTO nahradiť slučkami WHILE, REPEAT a DO (kapitoly 28 a 29).

Časté chyby#

Interpreter na Atari by skok na neexistujúci riadok ohlásil až počas behu (chyba 12), a len keby naň program naozaj prišiel. Prekladač to vidí hneď.

Vyskúšaj si#

1. Vypíš čísla od 10 do 1 pomocou IF a GOTO.
2. Uprav guess.abas, aby po šiestich pokusoch prezradil číslo a skončil.
3. Spýtaj sa na číslo; kým nie je medzi 1 a 10, pýtaj sa znova.

Zhrnutie#

• GOTO n pokračuje riadkom n.
• Skok dozadu je slučka; potrebuje IF, ktorým sa z nej dá vyjsť.
• IF … THEN 100 je skratka za IF … THEN GOTO 100.
• Riadok, na ktorý sa skáče, musí existovať.

Späť: 8. Podmienka · Ďalej: 10. Slučka s počítadlom

10. Slučka s počítadlom: FOR, TO, STEP, NEXT#

Na čo to je#

Najčastejšia slučka zo všetkých: „sprav toto desaťkrát“ alebo „prejdi čísla od 1 do 100“. FOR sa o počítanie postará sám.

Ako sa to píše#

FOR premenná=začiatok TO koniec
  príkazy
NEXT premenná

alebo s krokom:

FOR premenná=začiatok TO koniec STEP krok
  príkazy
NEXT premenná

Telo slučky je všetko medzi FOR a NEXT. Môže byť na ďalších riadkoch, alebo na tom istom riadku za dvojbodkou.

Celý program#

Súbor examples/for.abas:

10 REM FOR: a loop with a counter
20 FOR I=1 TO 10
30   PRINT I;" ";
40 NEXT I
50 PRINT
60 FOR I=0 TO 20 STEP 5:PRINT I;" ";:NEXT I
70 PRINT
80 FOR I=5 TO 1 STEP -1:PRINT I;" ";:NEXT I
90 PRINT "Go!"
100 PRINT
110 PRINT "The 7 times table:"
120 FOR ROW=1 TO 10
130   PRINT ROW;" x 7 = ";ROW*7
140 NEXT ROW
150 PRINT
160 FOR ROW=1 TO 4
170   FOR COL=1 TO ROW
180     PRINT "*";
190   NEXT COL
200   PRINT
210 NEXT ROW
220 SUM=0
230 FOR I=1 TO 100:SUM=SUM+I:NEXT I
240 PRINT "1+2+...+100 = ";SUM

Preklad a spustenie#

Basic26 for.abas --sim

Čo uvidíš#

1 2 3 4 5 6 7 8 9 10 
0 5 10 15 20 
5 4 3 2 1 Go!

The 7 times table:
1 x 7 = 7
2 x 7 = 14
3 x 7 = 21
4 x 7 = 28
5 x 7 = 35
6 x 7 = 42
7 x 7 = 49
8 x 7 = 56
9 x 7 = 63
10 x 7 = 70

*
**
***
****
1+2+...+100 = 5050

Ako to funguje#

• Riadky 20 až 40: I ide od 1 do 10 vrátane. Počítadlo sa dá v tele normálne používať – tu sa vypisuje.
• Riadok 60: celá slučka na jednom riadku. STEP 5 zväčšuje I po piatich.
• Riadok 80: záporný krok počíta nadol. Bez STEP -1 by to nešlo.
• Riadky 120 až 140: počítadlo ROW vstupuje do výpočtu ROW*7.
• Riadky 160 až 210: slučka v slučke. Vonkajšia ide po riadkoch, vnútorná vypíše toľko hviezdičiek, aké je číslo riadka. Vnútorná slučka má ako koniec premennú ROW – koniec nemusí byť číslo. Vnútorná slučka musí byť celá vo vonkajšej: najprv NEXT COL, potom NEXT ROW.
• Riadky 220 až 240: zbieranie súčtu. Pred slučkou sa SUM vynuluje a v každom prechode sa k nemu pripočíta I.

Telo slučky je odsadené o dve medzery za číslom riadka. BASIC tie medzery ignoruje (Atari BASIC ich pri písaní zahodí, Turbo-BASIC XL vo výpise odsadzuje sám), ale je z nich na prvý pohľad vidieť, čo k čomu patrí – a ktorá slučka nemá NEXT.

Začiatočníci často volajú počítadlá I, J, K. Je to zvyk z matematiky; meno ako ROW alebo COL však hovorí viac.

Štyri vlastnosti, ktoré treba poznať#

1. Telo sa vykoná vždy aspoň raz. FOR I=5 TO 1 bez záporného kroku telo jedenkrát vykoná (s I = 5) a až NEXT zistí, že je za koncom. Tak sa správa Atari BASIC aj Turbo-BASIC XL.

2. Po skončení slučky je počítadlo o krok ďalej. Po FOR I=1 TO 3 je v I číslo 4.

3. Koniec a krok sa vypočítajú raz, pri vstupe do slučky. Keď v tele zmeníš premennú, ktorá bola koncom, počet prechodov sa už nezmení.

4. Krok môže byť desatinný: FOR X=0 TO 1 STEP 0.25 prejde 0, 0.25, 0.5, 0.75 a 1.

Čakacia slučka#

V starých programoch často nájdeš prázdnu slučku:

500 FOR W=1 TO 300:NEXT W

Nerobí nič, len počíta – a tým spomaľuje. V interpreteri trvalo tristo prechodov asi pol sekundy a programátori si tak robili prestávky. Preložený program je však mnohokrát rýchlejší, takže prestávka skoro zmizne. Presné čakanie, ktoré od rýchlosti nezávisí, je v kapitolách 18 (časovač Atari) a 33 (PAUSE v Turbo-BASICu XL); pre dobové programy má prekladač voľbu --line-delay (kapitola 42).

Časté chyby#

Vyskúšaj si#

1. Vypíš párne čísla od 2 do 20.
2. Vypíš malú násobilku celú: desať riadkov a v každom desať čísel. (Slučka v slučke a čiarka v PRINT.)
3. Spýtaj sa na číslo N a vypíš súčin čísel od 1 do N (faktoriál).

Zhrnutie#

• FOR I=a TO b … NEXT I vykoná telo pre I od a po b vrátane.
• STEP n mení krok; bez neho je 1, záporný počíta nadol.
• Telo sa vykoná aspoň raz.
• Slučky sa smú vnárať, nie krížiť.
• Čakacia slučka je v preloženom programe oveľa kratšia než v interpreteri.

Späť: 9. Skok · Ďalej: 11. Podprogramy

11. Podprogramy: GOSUB, RETURN, POP#

Na čo to je#

Keď program potrebuje tú istú vec na viacerých miestach – podčiarknuť nadpis, počkať na kláves, nakresliť panáčika –, nemusí ju písať zakaždým znova. Napíše ju raz ako podprogram a z rôznych miest ju volá.

Ako sa to píše#

GOSUB číslo riadka
…
RETURN

GOSUB je GOTO s pamäťou. Rozdiel je práve v tom návrate: podprogram nemusí vedieť, kto ho zavolal.

Celý program#

Súbor examples/gosub.abas:

10 REM GOSUB: a piece of program with a way back
20 DIM T$(30)
30 T$="First":GOSUB 1000
40 T$="Second title":GOSUB 1000
50 N=3:GOSUB 2000
60 N=10:GOSUB 2000
70 END
1000 REM Print T$ underlined
1010 PRINT T$
1020 FOR I=1 TO LEN(T$):PRINT "-";:NEXT I
1030 PRINT
1040 RETURN
2000 REM Print the square and the cube of N
2010 PRINT N;" squared is ";N*N;", cubed ";N*N*N
2020 RETURN

Preklad a spustenie#

Basic26 gosub.abas --sim

Čo uvidíš#

First
-----
Second title
------------
3 squared is 9, cubed 27
10 squared is 100, cubed 1000

Ako to funguje#

• Riadky 30 až 60 sú hlavný program. Je krátky a číta sa ako zoznam úloh.
• Riadky 1000 až 1040 sú podprogram, ktorý vypíše text z T$ a podčiarkne ho pomlčkami. Volá sa dvakrát, zakaždým s iným textom.
• Ako podprogram dostane údaje: cez obyčajné premenné. Hlavný program pred volaním uloží text do T$ (alebo číslo do N) a podprogram si ho odtiaľ vezme. BASIC nemá „parametre“; všetky premenné sú spoločné pre celý program.
• Riadok 70, END, je tu nutný. Bez neho by program po riadku 60 pokračoval ďalej na riadok 1000, vbehol do podprogramu a jeho RETURN by sa nemal kam vrátiť.

Zvykom je dávať podprogramy na vysoké čísla riadkov (1000, 2000 …) a každý začať komentárom, čo robí a ktoré premenné číta.

Podprogram môže volať ďalší podprogram. Návraty sa pamätajú v poradí – každý RETURN sa vráti k tomu GOSUB, ktorý bol posledný.

Pozor na spoločné premenné#

Podprogram na riadku 1000 používa počítadlo I. Keby hlavný program volal GOSUB 1000 z vnútra vlastnej slučky FOR I=…, podprogram by mu počítadlo prepísal. Pomôcť si musíš sám: podprogramy nech používajú iné mená premenných než hlavný program.

POP#

Niekedy sa z podprogramu nechceš vrátiť – napríklad hráč v ňom prehral a program má skočiť rovno na koniec hry. Obyčajný GOTO z podprogramu by nechal zapamätaný návrat „visieť“. POP ho zahodí:

1050 IF LIVES=0 THEN POP:GOTO 5000

Je to zriedkavý príkaz; v dobových programoch ho občas stretneš.

Časté chyby#

Vyskúšaj si#

1. Napíš podprogram, ktorý vypíše riadok z N hviezdičiek, a zavolaj ho pre 5, 10 a 15.
2. Pridaj do gosub.abas podprogram, ktorý T$ vypíše v rámčeku z pomlčiek nad aj pod textom.
3. Zmaž riadok 70 a pozri, na ktorom riadku a s akou chybou program skončí.

Zhrnutie#

• GOSUB n zavolá podprogram na riadku n, RETURN sa vráti za GOSUB.
• Údaje sa podprogramu odovzdávajú v premenných; všetky premenné sú spoločné.
• Pred podprogramami musí byť END (alebo GOTO), aby do nich program nevbehol.
• Chyba 16 znamená RETURN, ktorý sa nemá kam vrátiť.

Späť: 10. Slučka s počítadlom · Ďalej: 12. Výber z možností

12. Výber z možností: ON … GOTO, ON … GOSUB#

Na čo to je#

Ponuka s piatimi možnosťami by potrebovala päť riadkov IF C=1 THEN …, IF C=2 THEN …. ON to spraví jedným príkazom: podľa čísla vyberie jeden riadok zo zoznamu.

Ako sa to píše#

ON výraz GOTO riadok1,riadok2,riadok3
ON výraz GOSUB riadok1,riadok2,riadok3

ON … GOSUB volá vybraný riadok ako podprogram a po RETURN pokračuje za príkazom ON.

Celý program#

Súbor examples/on.abas je malá kalkulačka s ponukou:

10 REM ON: choosing one of several lines
20 PRINT "1 Add  2 Multiply  3 Quit"
30 PRINT "Your choice";
40 INPUT C
50 IF C=3 THEN PRINT "Bye":END
60 PRINT "Two numbers";
70 INPUT A,B
80 ON C GOSUB 200,300
90 GOTO 20
200 PRINT A;" + ";B;" = ";A+B
210 RETURN
300 PRINT A;" * ";B;" = ";A*B
310 RETURN

Preklad a spustenie#

Basic26 on.abas --run

alebo v simulátore s odpoveďami zo súboru examples/on.in:

Basic26 on.abas --sim --sim-input on.in

Čo uvidíš#

1 Add  2 Multiply  3 Quit
Your choice?1
Two numbers?3,4
3 + 4 = 7
1 Add  2 Multiply  3 Quit
Your choice?2
Two numbers?3,4
3 * 4 = 12
1 Add  2 Multiply  3 Quit
Your choice?3
Bye

Ako to funguje#

• Riadok 80: keď je C jedna, zavolá sa podprogram na riadku 200; keď dva, na riadku 300.
• Riadok 90: po návrate z podprogramu sa ide späť na ponuku.
• Keď človek napíše číslo, ktoré v ponuke nie je (napríklad 7), ON neurobí nič a ponuka sa ukáže znova. Program sa teda nepokazí, len na voľbu nereaguje.
• Hodnota nemusí byť celá – zaokrúhli sa. ON 2.7 GOTO … vyberie tretí riadok.

Za ON môže byť ľubovoľný výraz. Často sa hodnota najprv upraví, aby začínala jednotkou:

ON K-48 GOTO 100,200,300

(Kláves s číslicou 1 má kód 49, o kódoch je kapitola 15.)

Časté chyby#

Vyskúšaj si#

1. Pridaj do kalkulačky odčítanie a delenie; Quit nech je päťka.
2. Ošetri voľbu mimo ponuky: vypíš No such choice.
3. Napíš program, ktorý sa spýta na číslo dňa (1–7) a cez ON … GOTO vypíše jeho meno.

Zhrnutie#

• ON X GOTO a,b,c skočí na riadok podľa hodnoty X: 1 je prvý, 2 druhý …
• ON X GOSUB a,b,c ho zavolá ako podprogram.
• Hodnota mimo zoznamu neurobí nič.
• Hodí sa na ponuky a všade, kde by bol dlhý rad IF.

Späť: 11. Podprogramy · Ďalej: 13. Polia

13. Polia: DIM A(n), DIM A(n,m), CLR#

Na čo to je#

Sedem teplôt za týždeň by potrebovalo sedem premenných a sedem skoro rovnakých riadkov na každú vec, ktorú s nimi chceš urobiť. Pole je rad čísel pod jedným menom: TEMP(0), TEMP(1) … TEMP(6). Číslo v zátvorke – index – môže byť premenná, a tak pole prejde jedna slučka.

Ako sa to píše#

DIM meno(najväčší index)
DIM meno(riadky,stĺpce)
meno(index)=hodnota

Indexy sa počítajú od nuly. Veľa programov nulu nepoužíva a počíta od jednotky – nevadí, jeden prvok ostane nevyužitý.

Pole môže držať len čísla. Pole reťazcov Atari BASIC nemá; ako ho obísť, je na konci kapitoly.

Celý program#

Súbor examples/arrays.abas:

10 REM Arrays: many numbers under one name
20 DIM TEMP(6)
30 TEMP(0)=12:TEMP(1)=14:TEMP(2)=11:TEMP(3)=17
40 TEMP(4)=19:TEMP(5)=16:TEMP(6)=13
50 SUM=0:HIGH=0
60 FOR D=0 TO 6
70   SUM=SUM+TEMP(D)
80   IF TEMP(D)>TEMP(HIGH) THEN HIGH=D
90 NEXT D
100 PRINT "Average: ";SUM/7
110 PRINT "Warmest day: ";HIGH;" with ";TEMP(HIGH)
120 REM A table with rows and columns
130 DIM T(3,3)
140 FOR R=1 TO 3:FOR C=1 TO 3
150     T(R,C)=R*C
160 NEXT C:NEXT R
170 FOR R=1 TO 3
180   PRINT T(R,1),T(R,2),T(R,3)
190 NEXT R

Preklad a spustenie#

Basic26 arrays.abas --sim

Čo uvidíš#

Average: 14.5714285
Warmest day: 4 with 19
1         2         3
2         4         6
3         6         9

Ako to funguje#

• Riadok 20: DIM TEMP(6) vyhradí sedem čísel. Tak ako pri reťazcoch, pole treba ohlásiť skôr, než ho použiješ.
• Riadky 30 a 40: naplnenie po jednom. Pohodlnejšie to pôjde s DATA v kapitole 14.
• Riadky 60 až 90: jedna slučka prejde celé pole. TEMP(D) je zakaždým iný prvok, lebo D sa mení.
• Riadok 80: hľadanie najväčšieho. HIGH si nepamätá teplotu, ale index dňa, kedy bola najvyššia; samotnú teplotu potom dá TEMP(HIGH).
• Riadok 130: dvojrozmerné pole je tabuľka. Prvé číslo je riadok, druhé stĺpec.
• Riadky 140 až 160: dve slučky v sebe prejdú všetky políčka.

Po DIM v poli nemusia byť nuly#

Atari BASIC pole pri DIM nevynuluje – ostane v ňom, čo bolo v pamäti predtým. Kým do prvku niečo neuložíš, nespoliehaj sa, že je nulový. Ak nuly potrebuješ, daj ich tam slučkou:

30 FOR I=0 TO 6:TEMP(I)=0:NEXT I

Koľko pamäte pole zaberie#

Každé číslo má šesť bajtov. DIM A(1000) je šesť kilobajtov, a sedem takých polí sa už do Atari nezmestí – program skončí chybou 2. Jedno pole smie mať najviac 32 767 bajtov: DIM T(100,100) by ich chcelo vyše šesťdesiattisíc a skončí chybou 9.

CLR#

CLR vráti program do stavu ako na začiatku: číselné premenné sú nula, reťazce a polia neexistujú a treba ich ohlásiť znova. Zabudne aj otvorené slučky FOR a podprogramy GOSUB – NEXT za CLR je chyba 13, RETURN chyba 16; TRAP ostane. Použije sa zriedka – napríklad v hre, ktorá po skončení začína odznova a chce si polia pripraviť nanovo.

Zoznam slov bez poľa reťazcov#

Viac textov sa v Atari BASICu drží v jednom dlhom reťazci a vyberajú sa z neho časti rovnakej dĺžky:

10 DIM D$(21)
20 D$="MonTueWedThuFriSatSun"
30 FOR N=1 TO 7
40   PRINT D$(N*3-2,N*3)
50 NEXT N

Každý deň má tri písmená; N-tý sa začína na mieste N*3-2.

Časté chyby#

Vyskúšaj si#

1. Nájdi v arrays.abas aj najchladnejší deň.
2. Naplň pole desiatimi číslami z klávesnice (INPUT v slučke) a vypíš ich v opačnom poradí.
3. Vypíš z tabuľky T len uhlopriečku: T(1,1), T(2,2), T(3,3).

Zhrnutie#

• Pole je rad čísel pod jedným menom; DIM A(n) má prvky 0 až n.
• Index môže byť premenná, preto pole prejde jedna slučka FOR.
• DIM A(r,s) je tabuľka.
• Index mimo poľa je chyba 9.
• Polia sú len číselné; viac textov sa drží v jednom reťazci.

Späť: 12. Výber z možností · Ďalej: 14. Dáta v programe

14. Dáta v programe: DATA, READ, RESTORE#

Na čo to je#

Program často potrebuje zoznam hodnôt, ktoré sa nemenia: mená mesiacov, noty melódie, body obrázka. Namiesto dvadsiatich riadkov A(0)=12:A(1)=14… ich napíšeš za sebou do riadkov DATA a program si ich po jednej číta.

Ako sa to píše#

DATA hodnota,hodnota,hodnota
READ premenná,premenná
RESTORE
RESTORE číslo riadka

Všetky DATA v programe tvoria jeden dlhý zoznam v poradí čísel riadkov. Program si pamätá, pokiaľ dočítal; každý READ vezme ďalšiu hodnotu.

Celý program#

Súbor examples/data.abas:

10 REM DATA: values written in the program
20 DIM NAME$(10)
30 FOR I=1 TO 4
40   READ NAME$,AGE
50   PRINT NAME$;" is ";AGE
60 NEXT I
70 RESTORE 1010
80 READ NAME$,AGE
90 PRINT "Again: ";NAME$
100 END
1000 DATA Anna,12
1010 DATA Boris,15,Cyril,9
1020 DATA Dana,11

Preklad a spustenie#

Basic26 data.abas --sim

Čo uvidíš#

Anna is 12
Boris is 15
Cyril is 9
Dana is 11
Again: Boris

Ako to funguje#

• Riadok 40: jeden READ vezme dve hodnoty za sebou – text do NAME$ a číslo do AGE. Štyri prechody slučky prečítajú osem hodnôt.
• Riadky 1000 až 1020: na tom, ako sú hodnoty rozdelené do riadkov, nezáleží. Riadok 1010 má dve dvojice, ostatné po jednej; READ ide jednoducho ďalej.
• Text v DATA sa píše bez úvodzoviek. Všetko medzi čiarkami je hodnota tak, ako je – vrátane medzier. Preto text v DATA nemôže obsahovať čiarku.
• Riadok 70: RESTORE 1010 vráti čítanie na začiatok riadka 1010, takže ďalší READ dostane Borisa.
• Riadok 100: END tu nie je nutný – DATA sa nevykonáva, program cez ne prejde bez účinku. Zvykom je však dávať dáta na koniec, za END.

Typický vzor: naplnenie poľa#

10 DIM TEMP(6)
20 FOR D=0 TO 6:READ X:TEMP(D)=X:NEXT D
30 DATA 12,14,11,17,19,16,13

Číta sa do pomocnej premennej X a tá sa uloží do poľa. Tak sa v kapitole 13 dali nahradiť dva riadky priradení.

Koniec zoznamu značkou#

Keď nechceš počítať, koľko hodnôt v DATA je, daj na koniec hodnotu, ktorá sa inak nevyskytne, a čítaj, kým na ňu nenarazíš:

10 READ X
20 IF X=-1 THEN END
30 PRINT X
40 GOTO 10
50 DATA 5,8,13,21,-1

Časté chyby#

Vyskúšaj si#

1. Pridaj do DATA piatu osobu a uprav slučku.
2. Prečítaj z DATA desať čísel a vypíš ich súčet.
3. Napíš program, ktorý sa spýta na číslo mesiaca a z DATA vypíše jeho meno. (Čítaj mená v slučke a zastav sa pri správnom.)

Zhrnutie#

• DATA drží hodnoty, READ ich číta jednu po druhej.
• Všetky DATA v programe sú jeden zoznam v poradí riadkov.
• RESTORE vráti čítanie na začiatok, RESTORE n na riadok n.
• Text v DATA je bez úvodzoviek a bez čiarok.
• Čítanie za koniec je chyba 6.

Späť: 13. Polia · Ďalej: 15. Znaky a čísla

15. Znaky a čísla: CHR$, ASC, STR$, VAL#

Na čo to je#

Počítač nepozná písmená, len čísla. Každý znak má svoj kód – A je 65, B je 66, medzera 32. Tabuľka kódov na Atari sa volá ATASCII. Štyri funkcie tejto kapitoly prevádzajú medzi znakom a jeho kódom a medzi číslom a textom.

Ako sa to píše#

Funkcie s dolárom na konci mena vracajú text, ostatné číslo.

Celý program#

Súbor examples/chars.abas:

10 REM CHR$, ASC, STR$, VAL
20 DIM A$(20),D$(10)
30 PRINT "The code of A is ";ASC("A")
40 PRINT "Character 66 is ";CHR$(66)
50 FOR C=65 TO 90:PRINT CHR$(C);:NEXT C
60 PRINT
70 A$="hello"
80 REM Small letters to capitals: 32 less
90 FOR I=1 TO LEN(A$)
100   C=ASC(A$(I,I))
110   IF C>=97 AND C<=122 THEN A$(I,I)=CHR$(C-32)
120 NEXT I
130 PRINT A$
140 REM A number into text and back
150 N=1234
160 D$=STR$(N)
170 PRINT D$;" has ";LEN(D$);" digits"
180 PRINT "The last digit is ";D$(LEN(D$))
190 PRINT VAL("12")+VAL("30")
200 PRINT VAL("3.5 apples")

Preklad a spustenie#

Basic26 chars.abas --sim

Čo uvidíš#

The code of A is 65
Character 66 is B
ABCDEFGHIJKLMNOPQRSTUVWXYZ
HELLO
1234 has 4 digits
The last digit is 4
42
3.5

Ako to funguje#

• Riadok 50: kódy 65 až 90 sú veľké písmená A až Z. Slučka cez kódy vypíše celú abecedu.
• Riadky 90 až 120: malé písmená majú kódy 97 až 122, presne o 32 viac než veľké. Slučka prejde text znak po znaku, a kde nájde malé písmeno, prepíše ho znakom s kódom o 32 menším. A$(I,I) je jeden znak – na čítanie aj na zápis.
• Riadok 160: STR$ spraví z čísla text. S textom sa dajú robiť veci, ktoré s číslom nejdú: spočítať číslice (LEN), vybrať poslednú, zarovnať stĺpec.
• Riadok 190: VAL robí opak. Dva texty, z ktorých sa stanú čísla, a tie sa sčítajú.
• Riadok 200: VAL číta číslo od začiatku textu a skončí pri prvom znaku, ktorý do čísla nepatrí.

Užitočné kódy#

PRINT CHR$(125) teda nevypíše znak, ale zmaže obrazovku. Atari má takých riadiacich kódov viac; všetky sú v prílohe D. Kódy 0 až 31 a 123 až 127 sú grafické znaky – čiarky, rohy a srdiečka, z ktorých sa skladali rámčeky.

Úvodzovka sa v texte v úvodzovkách napísať nedá. Keď ju chceš vypísať, pomôže jej kód: PRINT CHR$(34);"Hello";CHR$(34).

Časté chyby#

Vyskúšaj si#

1. Vypíš kódy všetkých znakov slova, ktoré človek napíše.
2. Otoč text naopak: prejdi ho od posledného znaku po prvý.
3. Spočítaj ciferný súčet čísla: preveď ho cez STR$ na text a sčítaj VAL jednotlivých znakov.

Zhrnutie#

• Každý znak má kód ATASCII; ASC dá kód, CHR$ znak.
• Veľké písmená sú 65–90, malé o 32 viac, číslice 48–57.
• STR$ robí z čísla text, VAL z textu číslo.
• VAL textu bez čísla je chyba 18.
• Niektoré kódy sú príkazy pre obrazovku: CHR$(125) ju zmaže.

Späť: 14. Dáta v programe · Ďalej: 16. Matematika a náhoda

16. Matematika a náhoda: SIN, COS, ATN, DEG, RAD, EXP, LOG, CLOG, RND#

Na čo to je#

Funkcie pre všetko, čo nejde štyrmi základnými znamienkami: uhly (kreslenie kruhov, pohyb po oblúku), mocniny a logaritmy – a RND, bez ktorého by nebola žiadna hra, lebo dáva náhodné číslo.

Ako sa to píše#

Tangens BASIC nemá, je to SIN(X)/COS(X). Číslo π tiež nie – ulož si ho do premennej.

Celý program#

Súbor examples/math.abas:

10 REM Mathematics and chance
20 DEG
30 PRINT "SIN(30) = ";SIN(30)
40 PRINT "COS(60) = ";COS(60)
50 PRINT "ATN(1) = ";ATN(1)
60 RAD
70 PI=3.14159265
80 PRINT "SIN(PI/2) = ";SIN(PI/2)
90 PRINT "EXP(1) = ";EXP(1)
100 PRINT "LOG(10) = ";LOG(10)
110 PRINT "CLOG(1000) = ";CLOG(1000)
120 PRINT "2^10 = ";2^10
130 REM Throwing a die: a whole number from 1 to 6
140 FOR I=1 TO 10
150   PRINT INT(RND(0)*6)+1;" ";
160 NEXT I
170 PRINT

Preklad a spustenie#

Basic26 math.abas --sim

Čo uvidíš#

SIN(30) = 0.499999999
COS(60) = 0.50000001
ATN(1) = 45.0000003
SIN(PI/2) = 1
EXP(1) = 2.71828179
LOG(10) = 2.30258509
CLOG(1000) = 3
2^10 = 1024
5 6 1 2 2 3 6 2 1 2 

Ako to funguje#

• Riadok 20: DEG prepne na stupne. Platí, kým ho nezmení RAD.
• Riadky 30 až 50: sínus tridsiatich stupňov je presne jedna polovica, ale Atari vypíše 0.499999999. Nie je to chyba prekladača – takto počíta Atari BASIC a preložený program dáva do poslednej číslice to isté. Funkcie sa počítajú približne a posledné miesto býva o kúsok vedľa. Preto výsledky funkcií neporovnávaj znakom = (kapitola 8).
• Riadok 70: π ako premenná. Na kreslenie v stupňoch ho nepotrebuješ.
• Riadok 150: najdôležitejší riadok kapitoly. RND(0) dá číslo ako 0.7312…; vynásobené šiestimi je od 0 po 5,99…; INT z neho spraví celé číslo 0 až 5; plus jedna je 1 až 6. Všeobecne:

INT(RND(0)*N)+1

je náhodné celé číslo od 1 do N. Na čísle v zátvorke RND nezáleží, zvykne sa písať nula.

Náhoda v simulátore a v emulátore#

V simulátore dostaneš pri každom spustení tie isté „náhodné“ čísla – preto môže táto kapitola ukázať, čo program vypíše. Na Atari a v emulátore sú zakaždým iné.

Hádanka s náhodným číslom#

Hra z kapitoly 9 potrebovala zmeniť jediný riadok:

20 SECRET=INT(RND(0)*100)+1:TRIES=0

Časté chyby#

Vyskúšaj si#

1. Vypíš tabuľku sínusov pre uhly 0, 15, 30 … 90 stupňov.
2. Hoď dvoma kockami stokrát a spočítaj, koľkokrát padol súčet 7. (Spusti v emulátore viackrát.)
3. Vyber náhodné písmeno abecedy: náhodné číslo 0–25, pripočítaj 65 a daj do CHR$.

Zhrnutie#

• SIN, COS, ATN počítajú v radiánoch, po DEG v stupňoch.
• EXP, LOG a CLOG sú mocniny a logaritmy; umocňovať sa dá aj znakom ^.
• RND(0) je náhodné číslo medzi 0 a 1; INT(RND(0)*N)+1 je celé od 1 do N.
• Výsledky funkcií sú približné – posledná číslica býva vedľa.

Späť: 15. Znaky a čísla · Ďalej: 17. Chyby za behu

17. Chyby za behu: TRAP, STOP, END, RUN#

Na čo to je#

Niektoré chyby sa pri preklade zistiť nedajú: človek napíše písmená namiesto čísla, delí sa nulou, súbor na diskete nie je. Program vtedy vypíše ERROR- a skončí. S TRAP (anglicky „pasca“) sa chyba dá zachytiť: namiesto konca program skočí na riadok, ktorý si určíš, a tam sa rozhodne, čo ďalej.

Ako sa to píše#

TRAP číslo riadka

PEEK číta bajt z pamäte počítača (kapitola 18); Atari si číslo chyby a riadok ukladá na tieto miesta. Zatiaľ ich ber ako zaklínadlo.

Pasca je na jedno použitie. Keď chyba nastane a program skočí, pasca je zrušená – ak ju chceš znova, musíš ju znova nastaviť.

A tri príkazy okolo konca programu:

Celý program#

Súbor examples/trap.abas:

10 REM TRAP: catching an error
20 TRAP 200
30 PRINT "Divide 100 by (999 ends)";
40 INPUT N
50 IF N=999 THEN PRINT "Bye":END
60 PRINT "100/";N;" = ";100/N
70 GOTO 20
200 REM An error brought us here
210 E=PEEK(195):L=PEEK(186)+256*PEEK(187)
220 PRINT "Error ";E;" at line ";L
230 IF E=8 THEN PRINT "That was not a number"
240 IF E=11 THEN PRINT "Cannot divide by zero"
250 GOTO 20

Preklad a spustenie#

Basic26 trap.abas --run

alebo v simulátore s odpoveďami zo súboru examples/trap.in (4, abc, 0, 999):

Basic26 trap.abas --sim --sim-input trap.in

Čo uvidíš#

Divide 100 by (999 ends)?4
100/4 = 25
Divide 100 by (999 ends)?abc
Error 8 at line 40
That was not a number
Divide 100 by (999 ends)?0
100/0 = Error 11 at line 60
Cannot divide by zero
Divide 100 by (999 ends)?999
Bye

Ako to funguje#

• Riadok 20 nastaví pascu. Kým nenastane chyba, nerobí nič.
• Odpoveď abc: INPUT N čaká číslo, takže je to chyba 8. Bez pasce by program skončil hlásením ERROR- 8 AT LINE 40. S pascou skočí na riadok 200.
• Riadok 210 si hneď odloží číslo chyby a riadok do premenných.
• Riadok 250 sa vracia na riadok 20, nie 30 – aby sa pasca nastavila znova.
• Odpoveď 0: PRINT na riadku 60 stihol vypísať začiatok (100/0 = ), až potom prišlo delenie a s ním chyba 11. Preto je hlásenie na tom istom riadku obrazovky.

Najčastejšie čísla chýb#

Celý zoznam je v prílohe C.

STOP a END#

Oba program ukončia. STOP k tomu vypíše, kde:

10 PRINT "A":STOP:PRINT "B"

A

STOPPED  AT LINE 10

Hodí sa pri hľadaní chyby: vieš, že program došiel až sem. Na Atari sa po STOP dalo pokračovať príkazom CONT; preložený program už pokračovať nevie.

Kláves BREAK na Atari robí to isté ako STOP – zastaví program a vypíše riadok.

RUN#

RUN v programe ho spustí odznova: premenné sú nula, polia a reťazce neexistujú, DATA sa čítajú od začiatku, pasca je zrušená. Hra tak môže po skončení začať novú:

900 PRINT "Again (Y/N)";:INPUT A$
910 IF A$="Y" THEN RUN

Časté chyby#

Vyskúšaj si#

1. Uprav program, aby pri chybe 8 vypísal Please type a number a inú chybu vypísal číslom.
2. Zmaž riadok 20 a zadaj abc. Ako vyzerá hlásenie bez pasce?
3. Napíš slučku, ktorá číta DATA bez toho, aby poznala ich počet: TRAP zachytí chybu 6 na konci zoznamu.

Zhrnutie#

• TRAP n pošle program pri chybe na riadok n namiesto toho, aby skončil.
• Pasca platí na jednu chybu; potom ju treba nastaviť znova.
• Číslo chyby je v PEEK(195), riadok v PEEK(186)+256*PEEK(187).
• STOP skončí s výpisom riadka, END potichu, RUN začne odznova.

Späť: 16. Matematika a náhoda · Ďalej: 18. Pamäť počítača

18. Pamäť počítača: PEEK, POKE, FRE, ADR#

Na čo to je#

Pamäť Atari je rad 65 536 očíslovaných priehradok. Číslo priehradky je adresa (0 až 65535) a v každej je jeden bajt – číslo od 0 do 255. V pamäti je tvoj program, jeho premenné, obrazovka aj nastavenia počítača: farby, okraje, hodiny, posledný stlačený kláves.

PEEK sa do priehradky pozrie a POKE do nej zapíše. Tak sa z BASICu dostaneš k veciam, na ktoré nemá príkaz.

Ako sa to píše#

Celý program#

Súbor examples/memory.abas:

10 REM PEEK and POKE: the memory of the computer
20 PRINT "Left margin: ";PEEK(82)
30 PRINT "Right margin: ";PEEK(83)
40 SCR=PEEK(88)+256*PEEK(89)
50 PRINT "The screen starts at ";SCR
60 DIM A$(5):A$="HELLO"
70 PRINT "The first byte of A$ is ";PEEK(ADR(A$))
80 POKE ADR(A$),74
90 PRINT A$
100 POKE 82,10
110 PRINT "Margin 10 from the next line on"
120 PRINT "Here it is"
130 POKE 82,2
140 PRINT "And back"

Preklad a spustenie#

Tentoraz s voľbou --sim-screen: simulátor na konci neukáže, čo program postupne vypísal, ale ako vyzerá obrazovka – aj s medzerami na začiatku riadkov.

Basic26 memory.abas --sim --sim-screen

Čo uvidíš#

  Left margin: 2
  Right margin: 39
  The screen starts at 48192
  The first byte of A$ is 72
  JELLO
  Margin 10 from the next line on
          Here it is
          And back

Ako to funguje#

• Riadky 20 a 30: na adresách 82 a 83 si Atari drží ľavý a pravý okraj textu. Ľavý okraj je 2 – preto každý riadok na obrazovke začína dvoma medzerami. (Staré televízory okraj obrazu orezávali.)
• Riadok 40: adresa pamäte obrazovky je väčšia než 255, takže zaberá dva bajty, 88 a 89. Druhý bajt má váhu 256. Tento vzorec stretneš v dobových programoch stále.
• Riadok 70: ADR(A$) je adresa prvého znaku reťazca. Je na nej 72 – kód písmena H.
• Riadok 80: POKE tam zapíše 74, kód písmena J, a z HELLO je JELLO. Reťazec sa zmenil bez toho, aby sa ho dotkol príkaz priradenia.
• Riadok 100: POKE 82,10 posunie ľavý okraj. Platí od najbližšieho nového riadka – preto je riadok 110 ešte na starom mieste a až riadok 120 odsadený.
• Riadok 130: okraj späť. Aj tu zmena platí až od ďalšieho riadka, takže And back je ešte odsadený.

Užitočné adresy#

Viac je v prílohe D. Najlepšia kniha o adresách Atari sa volá Mapping the Atari.

Hodiny a presné čakanie#

Bajt na adrese 20 sa sám od seba zväčší o jedna päťdesiatkrát za sekundu (na amerických strojoch šesťdesiatkrát). Keď doň zapíšeš nulu a počkáš, kým v ňom bude 50, prešla sekunda – nech je program akokoľvek rýchly. Súbor examples/wait.abas:

10 REM Waiting by the clock of the computer
20 FOR N=5 TO 1 STEP -1
30   PRINT N
40   S=50:GOSUB 1000
50 NEXT N
60 PRINT "Go!"
70 END
1000 REM Wait S fiftieths of a second (S up to 255)
1010 POKE 20,0
1020 IF PEEK(20)<S THEN 1020
1030 RETURN

Basic26 wait.abas --run

Program odpočíta od päť do jedna, s presne sekundovou prestávkou medzi číslami. Podprogram na riadku 1000 budú používať aj ďalšie kapitoly.

Tento program spúšťaj v emulátore. Hodiny poháňa obrazovka Atari a simulátor obrazovku nemá – bajt 20 v ňom stojí a riadok 1020 by sa točil donekonečna.

FRE(0)#

PRINT FRE(0) vypíše, koľko bajtov ostáva pre reťazce a polia, teda koľko ešte zoberie DIM. Preložený program dá iné číslo než ten istý program v interpreteri, lebo v pamäti leží inak. Na čísle v zátvorke nezáleží.

Časté chyby#

Vyskúšaj si#

1. Vypíš, na ktorom riadku a stĺpci je kurzor (PEEK(84), PEEK(85)).
2. Zmeň wait.abas, aby medzi číslami čakal pol sekundy.
3. Zisti kód posledného znaku reťazca: je na adrese ADR(A$)+LEN(A$)-1.

Zhrnutie#

• Pamäť sú bajty (0–255) na adresách 0–65535.
• PEEK(a) číta, POKE a,v zapisuje.
• Dvojbajtové číslo: PEEK(a)+256*PEEK(a+1).
• Na adrese 20 tikajú hodiny, 50 za sekundu – čakanie podľa nich nezávisí od rýchlosti programu.
• ADR(A$) je adresa textu reťazca, FRE(0) voľná pamäť.

Späť: 17. Chyby za behu · Ďalej: 19. Textová obrazovka

19. Textová obrazovka: POSITION, GRAPHICS 0, SETCOLOR#

Na čo to je#

PRINT píše tam, kde práve stojí kurzor – riadok za riadkom, zhora nadol. Na hru, ponuku alebo tabuľku to nestačí: chceš písať na presné miesto, obrazovku zmazať a zmeniť jej farby.

Ako sa to píše#

Obrazovka má 40 stĺpcov (0 až 39) a 24 riadkov (0 až 23). Miesto 0,0 je vľavo hore.

Odtieň je číslo 0 až 15, jas párne číslo 0 (tmavá) až 14 (svetlá):

Celý program#

Súbor examples/screen.abas:

10 REM The text screen
20 GRAPHICS 0
30 SETCOLOR 2,12,2:REM background: dark green
40 SETCOLOR 1,0,14:REM letters: bright
50 SETCOLOR 4,3,6:REM border: red
60 POKE 752,1:REM hide the cursor
70 POSITION 14,2:PRINT "A T A R I"
80 FOR X=10 TO 26
90   POSITION X,4:PRINT "-";
100 NEXT X
110 FOR Y=6 TO 10
120   POSITION Y,Y:PRINT "Row ";Y
130 NEXT Y
140 POSITION 2,20:PRINT "Bottom line";

Preklad a spustenie#

Farby ukáže len emulátor:

Basic26 screen.abas --run

Rozloženie textu ukáže aj simulátor s voľbou --sim-screen:

Basic26 screen.abas --sim --sim-screen

Čo uvidíš#

              A T A R I

          -----------------

      Row 6
       Row 7
        Row 8
         Row 9
          Row 10









  Bottom line

V emulátore je to isté svetlými písmenami na tmavozelenom pozadí s červeným okrajom, bez kurzora.

Ako to funguje#

• Riadok 20: GRAPHICS 0 začne s čistou obrazovkou a pôvodnými farbami. Na začiatku programu je to dobrý zvyk.
• Riadky 30 až 50: tri z piatich farebných registrov. V textovom režime má register 2 pozadie, register 1 jas písmen a register 4 okraj. Po zapnutí je obrazovka modrá: SETCOLOR 2,9,4.
• Riadok 70: POSITION 14,2 – najprv stĺpec, potom riadok. PRINT hneď za ním píše od toho miesta.
• Riadok 90: bodkočiarka na konci PRINT je tu dôležitá. Bez nej by kurzor po každej pomlčke prešiel na nový riadok – a keby to bolo v poslednom riadku obrazovky, celá obrazovka by sa posunula nahor.
• Riadky 110 až 130: pozícia môže byť vypočítaná.

Zmazanie obrazovky#

GRAPHICS 0 zmaže obrazovku a vráti farby. PRINT CHR$(125) ju len zmaže – farby aj skrytý kurzor ostanú. V dobových programoch nájdeš za PRINT v úvodzovkách zvláštny znak (zahnutú šípku); je to ten istý kód 125 napísaný rovno z klávesnice Atari.

Inverzné písmo#

Znaky s kódom o 128 väčším sa vypíšu inverzne – tmavé na svetlom. PRINT CHR$(65+128) je inverzné A. Tak sa robia zvýraznené nadpisy a „tlačidlá“.

Časté chyby#

Vyskúšaj si#

1. Nakresli z pomlčiek a znakov ! rámček okolo nadpisu.
2. Vypíš svoje meno do stredu obrazovky. (Stĺpec je (40-LEN(N$))/2.)
3. Vyskúšaj v slučke všetkých 16 odtieňov pozadia; medzi nimi čakaj pol sekundy podprogramom z kapitoly 18. Spusti v emulátore.

Zhrnutie#

• Obrazovka má 40 × 24 znakov, 0,0 je vľavo hore.
• POSITION stĺpec,riadok určí, kam bude písať ďalší PRINT.
• GRAPHICS 0 alebo PRINT CHR$(125) zmaže obrazovku.
• SETCOLOR 2 je pozadie, 1 jas písmen, 4 okraj.
• --sim-screen ukáže obrazovku tak, ako ju program nechal.

Späť: 18. Pamäť počítača · Ďalej: 20. Grafika

20. Grafika: GRAPHICS, COLOR, PLOT, DRAWTO, SETCOLOR, LOCATE#

Na čo to je#

Atari vie obrazovku prepnúť z písmen na body. Každý bod sa dá rozsvietiť jednou z niekoľkých farieb a z bodov a čiar vzniká obrázok.

Ako sa to píše#

Bod 0,0 je vľavo hore. x rastie doprava, y nadol – naopak ako v matematike.

Režimy#

Režimy 4, 6 a 14 sú dvojfarebné verzie režimov 5, 7 a 15. Úplná tabuľka je v prílohe D.

Pod obrázkom ostávajú štyri riadky textu – textové okno, do ktorého píše PRINT. Keď ho nechceš, pripočítaj k režimu 16: GRAPHICS 7+16 má obrázok cez celú obrazovku a 96 riadkov bodov namiesto 80.

Celý program#

Súbor examples/graphics.abas:

10 REM Graphics: a house in mode 7
20 GRAPHICS 7
30 SETCOLOR 4,9,2:REM background: dark blue
40 SETCOLOR 2,3,8:REM COLOR 3: red
50 COLOR 1
60 PLOT 50,70:DRAWTO 110,70:DRAWTO 110,40:DRAWTO 50,40:DRAWTO 50,70
70 COLOR 2
80 PLOT 45,40:DRAWTO 80,15:DRAWTO 115,40
90 COLOR 3
100 PLOT 75,70:DRAWTO 75,52:DRAWTO 87,52:DRAWTO 87,70
110 COLOR 1:PLOT 62,50:PLOT 98,50
120 LOCATE 80,15,C
130 PRINT "The roof top has colour ";C
140 PRINT "A house in GRAPHICS 7"

Preklad a spustenie#

Obrázok ukáže len emulátor:

Basic26 graphics.abas --run

Simulátor kreslí do pamäte, ktorú nevidíš, ale to, čo program vypíše do textového okna, ukáže:

Basic26 graphics.abas --sim

Čo uvidíš#

V emulátore: na tmavomodrom pozadí oranžový obrys domu, zelená strecha, červené dvere a dve bodky ako okná. Pod obrázkom v textovom okne dva riadky. V simulátore len tie dva riadky:

The roof top has colour 2
A house in GRAPHICS 7

Ako to funguje#

• Riadok 20: režim 7 má 160 bodov na šírku (x od 0 do 159) a 80 na výšku (y od 0 do 79).
• Riadok 50: COLOR 1 vyberie prvé pero. Bez COLOR by sa kreslilo perom 0, teda farbou pozadia – a nebolo by vidieť nič. To je najčastejšia chyba prvého grafického programu.
• Riadok 60: PLOT postaví pero do ľavého dolného rohu domu a štyri DRAWTO obídu obdĺžnik. Každý DRAWTO pokračuje tam, kde predošlý skončil.
• Riadky 70 až 100: iné pero, iná farba: strecha a dvere.
• Riadok 110: samotný PLOT je jeden bod.
• Riadok 120: LOCATE je opak PLOT: neuloží bod, ale prečíta ho. Vrchol strechy je nakreslený perom 2.
• Riadky 130 a 140: PRINT v grafickom režime píše do textového okna pod obrázkom.

Perá a farby#

COLOR nevyberá farbu, ale pero – číslo, ktoré sa uloží do bodu. Akú farbu to číslo na obrazovke má, hovorí farebný register a mení ho SETCOLOR. V režime 7:

SETCOLOR register,odtieň,jas: odtieň je 0 až 15 (0 sivá, 1 zlatá, 3 červená, 5 fialová, 7 a 9 modrá, 12 zelená, 14 žltozelená), jas párne číslo 0 (tmavá) až 14 (svetlá). Riadok 30 teda mení pozadie na tmavomodré a riadok 40 pero 3 na červené.

Zmena registra prefarbí všetko, čo je tým perom už nakreslené – okamžite a bez prekresľovania. Tak sa robili blikajúce a pulzujúce obrázky.

Vypĺňanie plôch#

Atari BASIC na vyplnenie plochy vlastný príkaz nemá (ide to len krkolomne cez XIO 18). Turbo-BASIC XL má FILLTO a PAINT, a tiež CIRCLE – kapitola 35.

Časté chyby#

Vyskúšaj si#

1. Dokresli domu komín a slnko z niekoľkých čiar.
2. Nakresli v režime 7 sto náhodných bodov náhodným perom 1 až 3.
3. Nakresli lúče: čiary zo stredu obrazovky (80,40) do bodov na hornom okraji, FOR X=0 TO 159 STEP 8.

Zhrnutie#

• GRAPHICS n prepne režim; +16 zruší textové okno.
• COLOR vyberie pero, PLOT kreslí bod, DRAWTO čiaru z posledného bodu.
• Bod 0,0 je vľavo hore.
• SETCOLOR mení farbu pera aj všetkého, čo ním už je nakreslené.
• Obrázok ukáže emulátor (--run), nie simulátor.

Späť: 19. Textová obrazovka · Ďalej: 21. Zvuk

21. Zvuk: SOUND#

Na čo to je#

Atari má štyri hlasy – štyri nezávislé zdroje zvuku. Každý vie hrať čistý tón alebo šum, a to naraz s ostatnými. Jeden príkaz hlas zapne a hrá, kým ho iný príkaz nezmení alebo nevypne.

Ako sa to píše#

SOUND hlas,výška,skreslenie,hlasitosť

SOUND hlas,0,0,0 hlas vypne.

Výšky pre tóny jednej oktávy (so skreslením 10):

O oktávu vyššie sú čísla približne polovičné, o oktávu nižšie dvojnásobné.

Celý program#

Súbor examples/sound.abas zahrá stupnicu:

10 REM SOUND: a scale
20 FOR I=1 TO 8
30   READ P
40   SOUND 0,P,10,8
50   S=15:GOSUB 1000
60 NEXT I
70 SOUND 0,0,0,0
80 END
1000 REM Wait S fiftieths of a second
1010 POKE 20,0
1020 IF PEEK(20)<S THEN 1020
1030 RETURN
2000 DATA 121,108,96,91,81,72,64,60

Preklad a spustenie#

Zvuk počuť len v emulátore (alebo na skutočnom Atari):

Basic26 sound.abas --run

V simulátore tento program nespúšťaj: čaká na hodiny počítača a tie v simulátore stoja (kapitola 18).

Čo uvidíš#

Nič – ale budeš počuť osem tónov stupnice C dur, každý necelú tretinu sekundy.

Ako to funguje#

• Riadok 30: výšky tónov sú v DATA na riadku 2000 a čítajú sa po jednej.
• Riadok 40: hlas 0 začne hrať tón. SOUND nečaká – program ide hneď ďalej a tón znie.
• Riadok 50: preto treba počkať. Podprogram na riadku 1000 čaká podľa hodín Atari, tu 15 päťdesiatin sekundy. Dĺžka čakania je dĺžka noty.
• Riadok 70: po poslednom tóne treba hlas vypnúť, inak by posledný tón znel ďalej. (Keď program skončí, preložený program zvuk vypne sám.)

Prečo nie čakacia slučka#

Dobové programy držia notu prázdnou slučkou FOR W=1 TO 100:NEXT W. V preloženom programe by takú melódiu nebolo počuť – prebehla by niekoľkokrát rýchlejšie. Čakanie podľa hodín trvá rovnako v interpreteri, v preloženom programe aj na rýchlejšom stroji.

Viac hlasov naraz#

Akord sú tri hlasy zapnuté po sebe:

10 SOUND 0,121,10,8
20 SOUND 1,96,10,8
30 SOUND 2,81,10,8

Súčet hlasitostí všetkých hlasov by nemal prekročiť asi 32, inak zvuk chrčí.

Zvukové efekty#

Efekt vzniká rýchlou zmenou výšky alebo hlasitosti v slučke:

10 REM A falling bomb
20 FOR P=30 TO 200:SOUND 0,P,10,8:NEXT P
30 REM An explosion
40 FOR V=15 TO 0 STEP -1:SOUND 0,90,8,V:S=4:GOSUB 1000:NEXT V

Skreslenie 8 je šum; s klesajúcou hlasitosťou znie ako výbuch.

Časté chyby#

Vyskúšaj si#

1. Zahraj stupnicu aj nadol.
2. Pridaj do DATA ku každej výške aj dĺžku noty a zahraj jednoduchú pesničku.
3. Sprav sirénu: výška stúpa od 60 po 120 a zasa klesá, päťkrát za sebou.

Zhrnutie#

• SOUND hlas,výška,skreslenie,hlasitosť zapne tón, ktorý hrá, kým ho nevypneš.
• Menšia výška je vyšší tón; skreslenie 10 je čistý tón.
• Dĺžku noty robí čakanie – podľa hodín, nie prázdnou slučkou.
• Štyri hlasy (0–3) môžu hrať naraz.

Späť: 20. Grafika · Ďalej: 22. Joystick a klávesy

22. Joystick a klávesy: STICK, STRIG, PADDLE, PTRIG#

Na čo to je#

Hra potrebuje vedieť, čo robí hráč – práve teraz, bez čakania na RETURN. Joystick, jeho tlačidlo aj klávesnica sa preto nečítajú príkazom INPUT, ale funkciami, ktoré vrátia okamžitý stav.

Programy tejto kapitoly sú pre emulátor. V emulátore atari800 sa joystick zvyčajne ovláda číselnou klávesnicou alebo šípkami a tlačidlo pravým klávesom Ctrl – presné nastavenie nájdeš v jeho ponuke (kláves F1).

Ako sa to píše#

Hodnoty STICK:

        14
    10      6
  11    15    7
     9      5
        13

15 je pokoj, 14 hore, 13 dole, 11 vľavo, 7 vpravo; uhlopriečky sú 10, 6, 9 a 5.

Celý program#

Súbor examples/joystick.abas:

10 REM Joystick: move a star, the button ends
20 GRAPHICS 0:POKE 752,1
30 X=20:Y=12
40 POSITION 2,0:PRINT "Joystick moves, the button ends";
50 POSITION X,Y:PRINT "*";
60 S=STICK(0)
70 IF STRIG(0)=0 THEN POSITION 2,22:PRINT "Bye":END
80 IF S=15 THEN 60
90 POSITION X,Y:PRINT " ";
100 IF S=14 AND Y>2 THEN Y=Y-1
110 IF S=13 AND Y<21 THEN Y=Y+1
120 IF S=11 AND X>2 THEN X=X-1
130 IF S=7 AND X<38 THEN X=X+1
140 W=3:GOSUB 1000
150 GOTO 50
1000 REM Wait W fiftieths of a second
1010 POKE 20,0
1020 IF PEEK(20)<W THEN 1020
1030 RETURN

Preklad a spustenie#

Basic26 joystick.abas --run

V simulátore program nespúšťaj – joystick tam nie je (STICK vracia stále 15) a program by nikdy neskončil.

Čo uvidíš#

Na obrazovke je hviezdička, ktorá sa hýbe podľa joysticku. Tlačidlo program ukončí.

Ako to funguje#

Je to kostra každej hry – slučka, ktorá dookola:

1. nakreslí hráča (riadok 50),
2. prečíta ovládač (riadky 60 a 70),
3. ak sa nič nedeje, číta znova (riadok 80),
4. zmaže hráča na starom mieste medzerou (riadok 90),
5. posunie súradnice, ale len ak neprejdú za okraj (riadky 100 až 130),
6. chvíľu počká (riadok 140) a ide odznova.

Čakanie v kroku 6 určuje rýchlosť hry. Bez neho by hviezdička v preloženom programe preletela obrazovku skôr, než pustíš joystick. Tri päťdesiatiny sekundy dávajú asi 17 krokov za sekundu.

Podmienky ako Y>2 držia hviezdičku na obrazovke. Bez nich by POSITION dostal súradnicu mimo a program by skončil chybou 141.

Uhlopriečky#

Program reaguje len na štyri základné smery. Aby šiel aj šikmo, testuj zvlášť vodorovný a zvislý smer:

100 IF (S=14 OR S=10 OR S=6) AND Y>2 THEN Y=Y-1
110 IF (S=13 OR S=9 OR S=5) AND Y<21 THEN Y=Y+1
120 IF (S=11 OR S=10 OR S=9) AND X>2 THEN X=X-1
130 IF (S=7 OR S=6 OR S=5) AND X<38 THEN X=X+1

Klávesy bez RETURN#

Atari si kód posledného stlačeného klávesu ukladá na adresu 764. Kým nikto nič nestlačil, je tam 255.

10 PRINT "Press any key"
20 POKE 764,255
30 IF PEEK(764)=255 THEN 30
40 PRINT "The key code was ";PEEK(764)
50 POKE 764,255

Riadok 20 „vyprázdni“ pamäť klávesu, riadok 30 čaká, kým sa v nej niečo objaví. Pozor: číslo na adrese 764 nie je kód ATASCII, ale číslo klávesu na klávesnici (A je 63, medzera 33, RETURN 12). Tabuľka je v prílohe D. Skutočný znak prečítaš cez zariadenie K: – kapitola 24.

Tri klávesy vpravo sa čítajú zvlášť, z adresy 53279:

10 PRINT "Press START"
20 IF PEEK(53279)<>6 THEN 20
30 PRINT "Here we go"

V simulátore sa tieto klávesy dajú „stlačiť“ voľbou --sim-console (kapitola 39).

Časté chyby#

Vyskúšaj si#

1. Pridaj pohyb po uhlopriečkach.
2. Nech stlačené tlačidlo neukončí program, ale zanechá na mieste hviezdičky znak #.
3. Sprav z toho hru: na náhodnom mieste je $; keď naň hviezdička príde, pripočítaj bod, pípni (SOUND) a daj $ inam.

Zhrnutie#

• STICK(0) vráti smer (15 = pokoj), STRIG(0) tlačidlo (0 = stlačené).
• Hra je slučka: nakresli, prečítaj, zmaž, posuň, počkaj.
• Kláves bez RETURN je v PEEK(764); START, SELECT a OPTION v PEEK(53279).
• Tieto programy patria do emulátora.

Späť: 21. Zvuk · Ďalej: 23. Strojový kód

23. Strojový kód: USR#

Na čo to je#

Procesor Atari rozumie len strojovému kódu – radu bajtov, z ktorých každý je jednoduchý pokyn. Je stokrát rýchlejší než BASIC v interpreteri, ale píše sa ťažko. Dobové programy ním robili to, čo BASIC nestíhal: rýchly presun obrazovky, hudbu, pohyb postavičiek.

USR je most: funkcia BASICu, ktorá zavolá strojový kód na danej adrese a vráti, čo jej kód odovzdá.

Túto kapitolu nemusíš vedieť naspamäť. Stačí, keď USR v cudzom programe spoznáš a vieš, že taký program sa dá preložiť tiež.

Ako sa to píše#

výsledok=USR(adresa)
výsledok=USR(adresa,hodnota,hodnota)

USR je funkcia, takže musí stáť vo výraze. Keď výsledok nepotrebuješ, píše sa X=USR(1536) a X sa jednoducho nepoužije.

Celý program#

Súbor examples/usr.abas má v DATA krátku rutinu, ktorá sčíta dve čísla:

10 REM USR: calling machine code
20 FOR I=0 TO 20:READ B:POKE 1536+I,B:NEXT I
30 PRINT "5 + 7 = ";USR(1536,5,7)
40 PRINT "1000 + 234 = ";USR(1536,1000,234)
50 END
1000 REM A routine that adds two numbers
1010 DATA 104,104,133,213,104,133,212
1020 DATA 104,170,104,24,101,212,133,212
1030 DATA 138,101,213,133,213,96

Preklad a spustenie#

Basic26 usr.abas --sim

Čo uvidíš#

5 + 7 = 12
1000 + 234 = 1234

Ako to funguje#

• Riadok 20: 21 bajtov z DATA sa cez POKE uloží do pamäte od adresy 1536. Adresy 1536 až 1791 (šestnástkovo $0600–$06FF, „šiesta stránka“) Atari necháva voľné práve na takéto krátke rutiny.
• Riadok 30: USR(1536,5,7) rutinu zavolá a odovzdá jej čísla 5 a 7.
• Čo rutina robí (pre zvedavých): BASIC jej pripraví na zásobník procesora počet hodnôt a potom každú hodnotu ako dva bajty. Rutina si ich musí všetky vyzdvihnúť – pokynom PLA, bajt 104. Súčet uloží na adresy 212 a 213; čo tam nájde BASIC po návrate (pokyn RTS, bajt 96), to je výsledok USR.

Rutina, ktorá si hodnoty zo zásobníka nevyzdvihne, sa nevráti tam, kam má, a počítač zamrzne. Na skutočnom Atari rovnako ako v preloženom programe.

Strojový kód v reťazci#

Druhý obľúbený spôsob: bajty rutiny sú znaky reťazca a volá sa USR(ADR(M$)). Vo výpise takého programu vidíš v úvodzovkách zhluk čudných znakov – to je strojový kód. Prekladač taký reťazec nechá bajt po bajte tak, ako je.

Čo s tým robí prekladač#

Preložený program volá USR rovnako ako interpreter, takže rutiny z dobových programov fungujú. Niektoré z nich však čítajú veci, ktoré patria interpreteru – napríklad text programu v riadkoch REM, alebo čakajú strojový kód či znakovú sadu nahraté z iného súboru. Na to má prekladač voľby --keep-rem, --embed a --reserve (kapitoly 42 a 43).

Časté chyby#

Vyskúšaj si#

1. Zavolaj rutinu s inými číslami. Čo vráti USR(1536,65535,1)? (Výsledok sa do dvoch bajtov nezmestí a „pretečie“.)
2. Nájdi v priečinku examples program, ktorý používa USR, a pozri, odkiaľ berie strojový kód – z DATA, z reťazca, alebo z REM.

Zhrnutie#

• USR(adresa,…) zavolá strojový kód a vráti jeho výsledok.
• Kód sa do pamäte dostane z DATA cez POKE, alebo je v reťazci.
• Šiesta stránka (1536–1791) je miesto na krátke rutiny.
• Preložený program volá USR tak isto ako interpreter.

Späť: 22. Joystick a klávesy · Ďalej: 24. Súbory

24. Súbory: OPEN, CLOSE, PRINT #, INPUT #, GET, PUT, STATUS, NOTE, POINT, XIO, LPRINT#

Na čo to je#

Premenné žijú, len kým program beží. Čo má prežiť vypnutie počítača – tabuľka najlepších výsledkov, uložená hra, zoznam adries –, musí ísť do súboru na diskete.

Atari sa na disketu, klávesnicu, obrazovku aj tlačiareň pozerá rovnako: ako na zariadenie, z ktorého sa číta alebo do ktorého sa píše. Program si k zariadeniu otvorí kanál a ďalej už pracuje s číslom kanála.

Ako sa to píše#

OPEN #kanál,režim,0,"zariadenie:meno"
PRINT #kanál;čo
INPUT #kanál,premenná
GET #kanál,premenná
PUT #kanál,hodnota
CLOSE #kanál

Zariadenia:

Meno súboru na diskete má najviac 8 znakov, bodku a najviac 3 znaky prípony; len veľké písmená a číslice.

Príkazy:

Celý program#

Súbor examples/files.abas zapíše tri riadky do súboru a prečíta ich späť:

10 REM Files: writing and reading
20 DIM L$(40)
30 OPEN #1,8,0,"D:NOTES.TXT"
40 PRINT #1;"First line"
50 PRINT #1;"Second line"
60 PRINT #1;12345
70 CLOSE #1
80 OPEN #1,4,0,"D:NOTES.TXT"
90 TRAP 140
100 INPUT #1,L$
110 PRINT "Read: ";L$
120 GOTO 100
140 CLOSE #1
150 PRINT "End of the file, error ";PEEK(195)

Preklad a spustenie#

Simulátor má disketu D: len v pamäti – súbor v nej vydrží do konca behu, čo na vyskúšanie stačí:

Basic26 files.abas --sim

V emulátore potrebuje program skutočnú disketu a na nej DOS – program, ktorý na Atari s disketami pracuje. Voľba --atr vyrobí obraz diskety s DOS-om, uloží naň preložený program tak, aby sa po zapnutí spustil sám, a --run z tej diskety emulátor naštartuje:

Basic26 files.abas --atr files.atr --run

Viac o disketách je v kapitole 41.

Čo uvidíš#

Read: First line
Read: Second line
Read: 12345
End of the file, error 136

Ako to funguje#

• Riadok 30: kanál 1 sa otvorí na zápis (režim 8). Ak súbor NOTES.TXT existuje, zmaže sa a začne odznova.
• Riadky 40 až 60: PRINT #1; píše do súboru presne to, čo by PRINT napísal na obrazovku. Za #1 je bodkočiarka (čiarka by vložila medzery ako na obrazovke). Číslo sa zapíše ako text.
• Riadok 70: CLOSE zapíše na disketu posledný kúsok dát a uvoľní kanál. Súbor, ktorý nezavrieš, je poškodený. Na konci programu (END alebo za posledným riadkom) zavrú kanály 1 až 7 oba interpretery aj preložený program; preložený navyše aj po STOP a chybe. Kým však program beží – a hlavne keď ho niekto zastaví klávesom RESET –, súbor bez CLOSE celý nie je.
• Riadok 80: ten istý kanál, teraz na čítanie (režim 4).
• Riadok 100: INPUT #1,L$ číta riadok po riadku.
• Riadok 90: program nevie, koľko riadkov v súbore je. Číta, kým to ide; pokus čítať za koniec je chyba 136 a pasca TRAP ju zachytí. To je bežný a správny spôsob, ako nájsť koniec súboru.
• Riadok 140: aj po chybe treba kanál zavrieť.

Čísla v súbore#

Číslo zapísané cez PRINT #1;N sa číta cez INPUT #1,N. Viac čísel na jednom riadku oddeľ čiarkou, ktorú zapíšeš sám: PRINT #1;A;",";B a potom INPUT #1,A,B.

Znak z klávesnice#

Zariadenie K: vráti kód ATASCII stlačeného klávesu a čaká, kým nejaký príde – bez RETURN a bez toho, aby sa znak objavil na obrazovke:

10 OPEN #2,4,0,"K:"
20 PRINT "Press a key"
30 GET #2,K
40 PRINT "You pressed ";CHR$(K);" (code ";K;")"
50 CLOSE #2

Na rozdiel od PEEK(764) z kapitoly 22 dostaneš skutočný znak.

Tlačiareň#

LPRINT "text" pošle riadok na tlačiareň. Robí to isté ako OPEN #7,8,0,"P:", PRINT #7;"text", CLOSE #7. Emulátor tlač ukladá do súboru.

XIO: operácie so súbormi#

Kanál za XIO musí byť zavretý. Tieto operácie robí DOS, takže ich skúšaj v emulátore s disketou, nie v simulátore. Turbo-BASIC XL má na ne obyčajné príkazy RENAME, DELETE, LOCK, UNLOCK a DIR (kapitola 37).

Časté chyby#

Chyby od 128 vyššie neprichádzajú z BASICu, ale z operačného systému a DOS-u. Všetky sú v prílohe C.

Vyskúšaj si#

1. Pripíš do NOTES.TXT štvrtý riadok režimom 9 a prečítaj súbor znova.
2. Ulož do súboru desať čísel z poľa a prečítaj ich späť do iného poľa.
3. Napíš program, ktorý sa spýta na meno a pri ďalšom spustení (v emulátore, s tou istou disketou) ťa ním pozdraví. Ak súbor ešte nie je, chybu 170 zachyť cez TRAP.

Zhrnutie#

• OPEN #kanál,režim,0,"D:MENO" – režim 4 číta, 8 píše, 9 pripisuje.
• PRINT # a INPUT # pracujú s riadkami, PUT # a GET # s bajtmi.
• CLOSE #kanál patrí za každý zápis; koniec programu kanály zavrie tiež, RESET nie.
• Koniec súboru je chyba 136; zachytí sa cez TRAP.
• Program s disketou sa do emulátora dáva s --atr disk.atr --run.

Späť: 23. Strojový kód · Ďalej: 25. Príkazy editora

25. Príkazy editora: LIST, LOAD, SAVE, NEW, CONT, DOS, BYE …#

Na čo to je#

Na skutočnom Atari je BASIC zároveň aj editor: píšeš doň riadky programu a medzi nimi príkazy, ktorými program vypíšeš, uložíš, spustíš. Niektoré z týchto príkazov nájdeš aj vo vnútri dobových programov – program sa sám vypíše, nahrá ďalšiu časť, alebo po skončení odíde do DOS-u.

Preložený program však nemá ani editor, ani svoj text. Táto kapitola hovorí, čo také príkazy urobia v ňom. Nie je to kapitola na učenie – je na nahliadnutie, keď ich stretneš.

Čo ktorý príkaz robí#