Action! pre začiatočníkov#

Príručka jazyka Action! pre 8-bitové počítače Atari, písaná pre ľudí, ktorí s Atari ani s Action! nikdy nerobili a programujú málo alebo vôbec. Programy sa píšu na dnešnom počítači s Windows, preloží ich prekladač action26 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/.

Predlohou je pôvodný manuál Action! od Optimized Systems Software. Časti o editore a monitore cartridge tu nie sú – action26 ich nepotrebuje.

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.

Kapitoly 1 až 31 platia aj pre pôvodný Action! na Atari. Kapitoly 32 až 42 sú o tom, čo vie action26 navyše.

Obsah#

Začíname#

Základy jazyka#

Rozhodovanie a opakovanie#

Rutiny#

Dáta#

Program a počítač#

Knižnica#

Čo má action26 navyše#

Prílohy#

1. Úvod#

Verzia dokumentácie Action26 1.3.0.361

Č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 dáš program z kazety, z diskety alebo 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 Action!#

Action! je programovací jazyk, ktorý pre Atari v roku 1983 vydala firma Optimized Systems Software. Predával sa ako cartridge. Stal sa obľúbeným, lebo programy v ňom sú skoro také rýchle ako programy písané priamo v strojovom kóde, a pritom sa čítajú ako obyčajný text:

PROC Main()
  PrintE("Hello, Atari!")
RETURN

Ak poznáš Pascal alebo C, veľa vecí ti bude povedomých. Ak nepoznáš nič, nevadí – táto kniha začína od nuly.

Čo je action26#

Pôvodný Action! bežal priamo na Atari: písalo sa na jeho klávesnici a prekladalo sa na ňom. action26 je prekladač toho istého jazyka, ktorý beží na počítači s Windows.

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

Jazyk je ten istý. Program z tejto knihy preloží aj pôvodný Action! (okrem kapitol 35 až 42, ktoré ukazujú, čo vie action26 navyše).

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 action26.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. Textový editor. Stačí Poznámkový blok. Pohodlnejší je editor, ktorý čísluje riadky, lebo prekladač hlási chyby číslom riadka.
4. 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:

5. Emulátor atari800 v priečinku atari800 vedľa action26.exe. Do kapitoly 26 ho nepotrebuješ. Emulátor potrebuje operačný systém Atari ako súbor ROM (ATARIXL.ROM vedľa atari800.exe). Namiesto neho poslúži aj voľná náhrada AltirraOS od Averyho Leeho – knižnica action26 volá operačný systém len cez jeho oficiálne vstupné body, takže s ňou funguje rovnako. Keď vedľa emulátora ATARIXL.ROM nie je a action26 nájde súbor external\Altirra\altirraos-xl.rom, použije pri --run sám AltirraOS.

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

Otvor príkazový riadok a napíš:

action26 --version

Mal by odpovedať svojou verziou, napríklad:

action26 1.3.0.301
Copyright (C) 2026 Pedro. MIT License.
Author web: https://action26.pohroma.de

Na prvom riadku je číslo verzie; posledné číslo (revízia) sa s každou novou verziou zväčšuje.

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

cd C:\Atari

.\action26 --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.act):

; My first program in Action!

PROC Main()
  PrintE("Hello, Atari!")
RETURN

Ulož ho ako hello.act. Prípona .act hovorí, že je to zdroják v jazyku Action!.

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.act.txt.

Preklad a spustenie#

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

action26 hello.act --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#

; My first program in Action!

Riadok, ktorý začína bodkočiarkou, je komentár. Prekladač ho preskočí. Je to poznámka pre človeka.

PROC Main()

PROC začína procedúru – pomenovaný kus programu. Táto sa volá Main. Prázdne zátvorky hovoria, že procedúra nedostáva žiadne údaje. Meno si môžeš zvoliť sám; Main (anglicky „hlavná“) je zvyk.

  PrintE("Hello, Atari!")

PrintE je hotová rutina z knižnice: vypíše text v zátvorkách a prejde na nový riadok. Text sa píše do úvodzoviek.

RETURN

RETURN končí procedúru. Keďže Main je jediná procedúra, končí tým aj celý program.

Medzery na začiatku riadka nie sú povinné. Píšu sa preto, aby bolo vidieť, čo patrí dovnútra procedúry.

Čo vzniklo na disku#

Po preklade pribudol vedľa zdrojáka súbor hello.xex. To je hotový program pre Atari – má 277 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:

action26 hello.act

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. Ak ho máš (priečinok atari800 vedľa action26.exe), spustíš program takto:

action26 hello.act --run

Tento program však skončí hneď po výpise a Atari po skončení programu ukáže svoju vlastnú obrazovku, takže text nestihneš prečítať. Preto sa do programov pre emulátor na koniec pridáva čakanie na kláves (examples/hello-key.act):

; Hello for the emulator: it waits for a key before it ends

PROC Main()
  PrintE("Hello, Atari!")
  PutE()
  Print("Press any key")
  GetD(7)
RETURN

action26 hello-key.act --run

GetD(7) čaká, kým na klávesnici Atari stlačíš kláves. Čo presne znamená sedmička, vysvetlí kapitola 30; zatiaľ ber GetD(7) ako „počkaj na kláves“.

Keď prekladač nájde chybu#

Chyby sú pri programovaní bežné. Skús úmyselne jednu spraviť: zmaž druhú úvodzovku.

PROC Main()
  PrintE("Hello, Atari!)
RETURN

Prekladač odpovie:

hello.act(2,10): error ACT001: missing double quote in string
hello.act(4,1): error ACT018: unmatched parentheses: expected ')', got 'end of file'

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

Dve rady:

• Opravuj vždy prvú chybu. Ďalšie sú často len jej následkom – tu druhé hlásenie zmizne, keď doplníš úvodzovku.
• 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, súbor .xex nevznikne a nič sa nespustí.

Časté chyby#

Veľké a malé písmená prekladač nerozlišuje: PrintE, printe aj PRINTE je to isté. V knihe sú slová jazyka veľkými písmenami (PROC, RETURN) a mená rutín s veľkým začiatočným písmenom, aby sa program dobre čítal.

Vyskúšaj si#

1. Zmeň text v úvodzovkách na svoje meno a program znova prelož a spusti.
2. Pridaj druhý riadok PrintE("…") s iným textom pod prvý.
3. Zmaž slovo RETURN a pozri, čo sa stane. (Nič – posledná procedúra programu sa skončí aj tak. Píš ho však vždy; v kapitole 3 uvidíš, prečo.)

Zhrnutie#

• Program je textový súbor s príponou .act.
• action26 meno.act ho preloží do meno.xex; --sim ho hneď spustí v simulátore, --run v emulátore.
• Program je zložený z procedúr: PROC Meno() … RETURN.
• PrintE("text") vypíše riadok textu.
• Riadok za ; je komentár.
• Chybové hlásenie hovorí súbor, riadok, stĺpec a dôvod. Opravuj od prvého.

Späť: 1. Úvod · Ďalej: 3. Rutiny

3. Rutiny: PROC a RETURN#

Na čo to je#

Program sa delí na menšie pomenované kusy – procedúry. Kus, ktorý sa opakuje, napíšeš raz a potom ho len voláš menom.

Ako sa to píše#

PROC Meno()
  príkazy
RETURN

Procedúra sa volá tak, že napíšeš jej meno so zátvorkami: Meno().

Komentár začína bodkočiarkou a siaha do konca riadka. Môže stáť na vlastnom riadku aj za príkazom.

Celý program#

Súbor examples/proc.act:

; Three routines. The program starts in the last one.

PROC Line()
  PrintE("--------------------")
RETURN

PROC Greet()
  PrintE("Good morning!")       ; a comment may follow a statement
RETURN

PROC Main()
  Line()
  Greet()
  Greet()
  Line()
RETURN

Preklad a spustenie#

action26 proc.act --sim

Čo uvidíš#

--------------------
Good morning!
Good morning!
--------------------

Ako to funguje#

Program má tri procedúry: Line, Greet a Main.

Program začína v poslednej procedúre. To je pravidlo Action! – nezáleží na mene, ale na poradí. Tu je posledná Main, takže program začne v nej.

Main postupne zavolá Line(), dvakrát Greet() a znova Line(). Pri každom volaní program odskočí do volanej procedúry, vykoná jej príkazy a po RETURN pokračuje za volaním.

Keď RETURN vykoná posledná procedúra (tá, v ktorej program začal), program končí.

Procedúra musí byť napísaná skôr, než ju niekto zavolá. Prekladač číta súbor zhora nadol a meno, ktoré ešte nevidel, nepozná. Preto sú pomocné procedúry hore a Main dole.

Časté chyby#

Chýbajúci RETURN prekladač nehlási. Procedúra bez RETURN neskončí a program pokračuje príkazmi nasledujúcej procedúry, čo skoro nikdy nechceš. Keby v tomto programe chýbal RETURN za Greet, program by z Greet „prepadol“ do Main, tá by znova zavolala Greet – a Good morning! by sa vypisovalo donekonečna. Na konci každej procedúry preto píš RETURN.

Vyskúšaj si#

1. Pridaj procedúru Bye, ktorá vypíše Good night!, a zavolaj ju z Main pred poslednou čiarou.
2. Presuň procedúru Main na začiatok súboru. Čo povie prekladač a prečo?
3. Zavolaj Line() aj z procedúry Greet. Koľko čiar program vypíše?

Zhrnutie#

• PROC Meno() … RETURN je procedúra; volá sa Meno().
• Program začína v poslednej procedúre súboru.
• Procedúra musí byť v súbore nad miestom, kde sa volá.
• RETURN na konci procedúry nevynechávaj.
• ; začína komentár do konca riadka.

Späť: 2. Prvý program · Ďalej: 4. Výpis

4. Výpis: Print, Put a výpis čísel#

Na čo to je#

Program, ktorý nič nevypíše, nevieš skontrolovať. Rutiny na výpis preto potrebuješ v každej kapitole. Sú súčasťou knižnice – netreba ich deklarovať, stačí ich zavolať.

Ako sa to píše#

Písmeno E na konci mena (z anglického End of line) znamená „a potom prejdi na nový riadok“. Majú ho aj rutiny na čísla: PrintBE, PrintCE, PrintIE.

Prečo sú na čísla tri rutiny, vysvetlí kapitola 6: písmená B, C a I sú tri druhy čísel – BYTE, CARD a INT.

Celý program#

Súbor examples/print.act:

; Writing texts, characters and numbers

PROC Main()
  Print("One ")              ; a text, the cursor stays on the line
  Print("line.")
  PutE()                     ; the end of the line

  PrintE("A line of its own.")

  Put('A)                    ; one character
  Put('B)
  Put('C)
  PutE()

  Print("A small number: ")
  PrintBE(200)               ; BYTE: 0 to 255

  Print("A big number: ")
  PrintCE(50000)             ; CARD: 0 to 65535

  Print("A number below zero: ")
  PrintIE(-150)              ; INT: -32768 to 32767

  PrintB(1) Put(' ) PrintB(2) Put(' ) PrintB(3)
  PutE()
RETURN

Preklad a spustenie#

action26 print.act --sim

Čo uvidíš#

One line.
A line of its own.
ABC
A small number: 200
A big number: 50000
A number below zero: -150
1 2 3

Ako to funguje#

• Dva Print za sebou píšu na ten istý riadok. Až PutE() riadok ukončí.
• PrintE robí oboje naraz: text aj koniec riadka.
• Put('A) vypíše jeden znak. Znak sa píše s jedným apostrofom pred ním a žiadnym za ním – viac v kapitole 5.
• Put(' ) je apostrof a medzera: vypíše medzeru.
• Posledný riadok ukazuje, že na jednom riadku môže byť viac príkazov. Stačí ich oddeliť medzerou; žiadna bodkočiarka ani čiarka medzi ne nepatrí.

Časté chyby#

Posledné dva riadky stoja za zapamätanie: Action! nekontroluje, či rutine dávaš to, čo čaká. Text patrí do Print, znak do Put, číslo do PrintB, PrintC alebo PrintI. Keď program vypíše niečo čudné, pozri najprv, či si nepomiešal tieto rutiny.

Odkiaľ sa vzalo 44? Do BYTE sa zmestí 256 hodnôt (0 až 255). 300 je o 44 viac ako 256, a práve ten zvyšok ostane.

Vyskúšaj si#

1. Vypíš svoje meno a vek na jeden riadok: Name: … Age: ….
2. Vypíš pomocou Put a PutE trojuholník z hviezdičiek na tri riadky.
3. Zmeň PrintIE(-150) na PrintCE(-150). Čo sa vypíše? (65386 – PrintC nepozná záporné čísla a to isté číslo číta inak.)

Zhrnutie#

• Print píše text, Put jeden znak.
• PrintB, PrintC, PrintI píšu čísla – podľa toho, aké veľké číslo to je a či môže byť záporné.
• E na konci mena pridá koniec riadka; samotný koniec riadka je PutE().
• Na riadku môže byť viac príkazov oddelených medzerou.
• Prekladač nekontroluje, či rutine dávaš správny druh údaja.

Späť: 3. Rutiny · Ďalej: 5. Čísla, znaky a texty

5. Čísla, znaky a texty#

Na čo to je#

Hodnotu môžeš do programu napísať štyrmi spôsobmi. Všetky štyri stretneš v každom programe pre Atari.

Ako sa to píše#

Šestnástková sústava v skratke#

V desiatkovej sústave máš desať číslic (0–9) a ďalšie miesto znamená desaťnásobok. V šestnástkovej je číslic šestnásť: 0 1 2 3 4 5 6 7 8 9 A B C D E F, kde A je desať a F pätnásť. Ďalšie miesto znamená šestnásťnásobok.

Prečo sa to používa: dve šestnástkové číslice sú presne jeden bajt (0 až 255) a adresy v pamäti Atari sa v knihách a časopisoch píšu takmer vždy takto. Počítať v nej nemusíš – stačí vedieť, že $41 a 65 je to isté číslo.

Znak je tiež číslo#

Počítač si znaky pamätá ako čísla – každý znak má svoj kód. Písmeno A má kód 65, B 66, medzera 32, číslica 0 48. Zápis 'A je teda len pohodlnejší spôsob, ako napísať 65.

Atari používa vlastnú tabuľku kódov, ATASCII. Pre písmená, číslice a bežné znamienka je rovnaká ako ASCII na dnešných počítačoch. Tabuľka je v prílohe D.

Celý program#

Súbor examples/numbers.act:

; The four ways to write a value

PROC Main()
  Print("Decimal 65: ")
  PrintBE(65)

  Print("Hexadecimal $41: ")
  PrintBE($41)               ; the same number, written in base 16

  Print("Character 'A: ")
  PrintBE('A)                ; a character is a number too - its code

  Print("Put(65): ")
  Put(65)                    ; and a number can be written as a character
  PutE()

  Print("$FFFF: ")
  PrintCE($FFFF)             ; the biggest CARD

  PrintE("A text with ""quotes"" inside.")
RETURN

Preklad a spustenie#

action26 numbers.act --sim

Čo uvidíš#

Decimal 65: 65
Hexadecimal $41: 65
Character 'A: 65
Put(65): A
$FFFF: 65535
A text with "quotes" inside.

Ako to funguje#

• Prvé tri výpisy dajú zakaždým 65: 65, $41 a 'A sú tri zápisy toho istého čísla.
• Put(65) vypíše A. Rutina Put berie číslo ako kód znaku; PrintB ho berie ako číslo. Hodnota je tá istá, líši sa len to, čo s ňou rutina spraví.
• $FFFF je najväčšie číslo, ktoré sa zmestí do dvoch bajtov.
• Úvodzovku vnútri textu napíšeš zdvojenú: "".

Časté chyby#

Šestnástkové číslice píš veľkými písmenami ($FF, nie $ff). action26 prijme aj malé, pôvodný Action! nie.

Vyskúšaj si#

1. Vypíš kódy znakov 'a, 'z, '0 a '9 pomocou PrintBE.
2. Vypíš Put(72) Put(105) – aké slovo to je?
3. Koľko je $100? Tipni si a over to cez PrintCE($100).

Zhrnutie#

• Číslo sa píše desiatkovo (65) alebo šestnástkovo ($41).
• Znak sa píše s jedným apostrofom pred ním ('A) a je to číslo – kód znaku.
• Text sa píše do úvodzoviek; úvodzovka v texte sa zdvojí.
• Desatinné čísla Action! nemá.

Späť: 4. Výpis · Ďalej: 6. Premenné

6. Premenné: BYTE, CARD, INT, CHAR#

Na čo to je#

Premenná je pomenované miesto v pamäti, do ktorého si program odloží hodnotu, aby ju mohol neskôr použiť alebo zmeniť. Bez premenných by program vedel len vypisovať to, čo máš napísané v zdrojáku.

Ako sa to píše#

Premennú treba najprv deklarovať – povedať, ako sa volá a aký druh hodnoty v nej bude:

BYTE age
CARD year, score          ; viac premenných toho istého typu, oddelené čiarkou
INT  temperature
CHAR grade
BYTE lives=[3]            ; premenná, ktorá má hodnotu hneď od začiatku

Druh hodnoty sa volá typ. Action! má štyri základné:

CARD je skratka z cardinal (číslo bez znamienka), INT z integer (celé číslo).

Hodnotu do premennej vloží priradenie: meno=hodnota.

Deklarácie patria na začiatok procedúry, pred prvý príkaz.

Celý program#

Súbor examples/variables.act:

; Variables of the four basic types

PROC Main()
  BYTE age                   ; 0 to 255
  CARD year                  ; 0 to 65535
  INT  temperature           ; -32768 to 32767
  CHAR grade                 ; one character
  BYTE lives=[3]             ; a variable with a value from the start

  age=12
  year=1983
  temperature=-5
  grade='A

  Print("Age: ")          PrintBE(age)
  Print("Year: ")         PrintCE(year)
  Print("Temperature: ")  PrintIE(temperature)
  Print("Grade: ")        Put(grade) PutE()
  Print("Lives: ")        PrintBE(lives)

  age=13                     ; a variable can change
  Print("Next year: ")    PrintBE(age)
RETURN

Preklad a spustenie#

action26 variables.act --sim

Čo uvidíš#

Age: 12
Year: 1983
Temperature: -5
Grade: A
Lives: 3
Next year: 13

Ako to funguje#

• Prvých päť riadkov procedúry sú deklarácie. Až po nich idú príkazy.
• age=12 uloží do premennej age číslo 12. Odvtedy sa dá age napísať všade, kde by mohlo stáť číslo – napríklad v PrintBE(age).
• Typ premennej určuje, ktorou rutinou ju vypíšeš: BYTE cez PrintB, CARD cez PrintC, INT cez PrintI, CHAR cez Put.
• lives=[3] v deklarácii dá premennej hodnotu už pri nahraní programu. Hranaté zátvorky sú tu povinné.
• age=13 starú hodnotu prepíše. Premenná si pamätá vždy len poslednú.

Ako vybrať typ#

• Zmestí sa hodnota vždy do 0 až 255? Použi BYTE. Je najrýchlejší a zaberie najmenej miesta – procesor Atari počíta po jednom bajte.
• Môže byť hodnota záporná? Použi INT.
• Inak CARD.

Časté chyby#

Posledný riadok je najzákernejší. BYTE lives=3 nedá premennej hodnotu 3. Znamená „premenná lives leží v pamäti na adrese 3“. Na to sa hodí pri práci s pamäťou počítača (kapitola 24), ale začiatočník tým prepíše niečo, čo patrí systému. Počiatočná hodnota sa píše vždy do hranatých zátvoriek: BYTE lives=[3].

Premenná, ktorej si nič nepriradil, má po nahraní programu hodnotu 0. Nespoliehaj sa na to – keď program spustíš druhýkrát bez nového nahrania, ostane v nej to, čo tam bolo naposledy.

Vyskúšaj si#

1. Pridaj premennú CARD score s počiatočnou hodnotou 1000 a vypíš ju.
2. Zmeň temperature na typ BYTE a pozri, čo sa vypíše pri temperature=-5. (Použi PrintBE. Vyjde 251 – BYTE záporné čísla nemá.)
3. Priraď do grade znak 'B a potom číslo 66. Líši sa výpis?

Zhrnutie#

• Premenná sa deklaruje typom a menom na začiatku procedúry.
• BYTE a CHAR 0–255, CARD 0–65535, INT −32768 až 32767.
• meno=hodnota do premennej uloží hodnotu; stará sa stratí.
• Počiatočná hodnota je v hranatých zátvorkách: BYTE lives=[3]. Bez nich je to adresa.
• Hodnota, ktorá sa do typu nezmestí, sa skráti – prekladač to pri číslach v zdrojáku ohlási varovaním.

Späť: 5. Čísla, znaky a texty · Ďalej: 7. Počítanie

7. Počítanie: výrazy a priradenie#

Na čo to je#

Program počíta: sčíta skóre, zistí, koľko ostáva životov, prepočíta súradnice. Zápis výpočtu sa volá výraz a jeho výsledok sa zvyčajne uloží do premennej.

Ako sa to píše#

premenná = výraz

Znak = tu neznamená „rovná sa“ ako v matematike. Znamená „vypočítaj to, čo je vpravo, a ulož to do premennej vľavo“. Preto dáva zmysel aj x=x+1: zober x, pripočítaj 1 a ulož späť do x.

Poradie: najprv zátvorky, potom *, / a MOD, nakoniec + a -. Operátory rovnakej sily sa počítajú zľava doprava.

Skrátené priradenie#

Zmeniť premennú o nejakú hodnotu je také časté, že má vlastný zápis:

Celý program#

Súbor examples/expr.act:

; Counting with numbers

PROC Main()
  BYTE a, b, small
  CARD result
  INT  x, y, diff

  a=17
  b=5

  result=a+b     Print("17 + 5 = ")      PrintCE(result)
  result=a-b     Print("17 - 5 = ")      PrintCE(result)
  result=a*b     Print("17 * 5 = ")      PrintCE(result)
  result=a/b     Print("17 / 5 = ")      PrintCE(result)
  result=a MOD b Print("17 MOD 5 = ")    PrintCE(result)

  result=2+3*4   Print("2 + 3 * 4 = ")   PrintCE(result)
  result=(2+3)*4 Print("(2 + 3) * 4 = ") PrintCE(result)

  diff=b-a       Print("5 - 17 with BYTE = ") PrintIE(diff)
  x=5 y=17
  diff=x-y       Print("5 - 17 with INT = ")  PrintIE(diff)

  small=250
  small=small+10 Print("250 + 10 in a BYTE = ") PrintBE(small)

  result=100
  result==+5     Print("100, then ==+5: ") PrintCE(result)
  result==*2     Print("then ==*2: ")      PrintCE(result)
RETURN

Preklad a spustenie#

action26 expr.act --sim

Čo uvidíš#

17 + 5 = 22
17 - 5 = 12
17 * 5 = 85
17 / 5 = 3
17 MOD 5 = 2
2 + 3 * 4 = 14
(2 + 3) * 4 = 20
5 - 17 with BYTE = 244
5 - 17 with INT = -12
250 + 10 in a BYTE = 4
100, then ==+5: 105
then ==*2: 210

Ako to funguje#

Delenie je celočíselné. 17 delené 5 je 3 a zvyšok 2. Výsledok delenia je 3, zvyšok dá MOD. Desatinné čísla Action! nemá.

Násobenie má prednosť pred sčítaním. 2+3*4 je 2 + 12 = 14. Ak chceš najprv sčítať, daj sčítanie do zátvoriek.

Dve pasce, ktoré treba poznať#

1. Typ výsledku určujú typy vo výraze, nie premenná, do ktorej ukladáš.

diff=b-a počíta 5 − 17. Obe premenné sú BYTE, preto sa aj výsledok počíta ako BYTE – a ten záporný byť nemôže. Vyjde 244 a až táto hodnota sa uloží do diff. To, že diff je INT, už nepomôže.

V druhom výpočte sú x a y typu INT, výsledok je INT a vyjde správnych −12.

Pravidlo:

Keď výsledok môže vyjsť mimo 0 až 255, musí byť aspoň jedna premenná vo výraze väčšieho typu.

2. Pretečenie sa nehlási.

small=250 a small=small+10 dá 4, nie 260. BYTE má len 256 hodnôt a po 255 nasleduje znova 0 – ako počítadlo kilometrov, ktoré sa pretočí. Program nezastane ani nič nevypíše. Rovnako pretečie CARD za 65535 a INT za 32767.

Časté chyby#

Vyskúšaj si#

1. Koľko je 7/2*2? A 7*2/2? Vypočítaj si to najprv na papieri (pozor na celočíselné delenie) a over programom.
2. Vypíš počet hodín a minút v 200 minútach pomocou / a MOD.
3. Zmeň typ a a b na CARD a pozri, čo sa stane s výpisom 5 - 17 with BYTE.

Zhrnutie#

• premenná=výraz vypočíta výraz a uloží výsledok.
• / delí bez zvyšku, zvyšok dá MOD.
• Najprv zátvorky, potom * / MOD, potom + -.
• Výraz zo samých BYTE sa počíta v BYTE. Ak má vyjsť viac ako 255 alebo menej ako 0, použi vo výraze CARD alebo INT.
• Pretečenie program nehlási.
• x==+1 je skratka za x=x+1.

Späť: 6. Premenné · Ďalej: 8. Vstup

8. Vstup: InputB, InputC, InputI, InputS#

Na čo to je#

Doteraz program vedel len to, čo si mu napísal do zdrojáka. Rutiny vstupu počkajú, kým používateľ niečo napíše na klávesnici a stlačí RETURN (Enter), a napísanú hodnotu odovzdajú programu.

Ako sa to píše#

Prvé tri sú funkcie: vrátia hodnotu a tú priradíš do premennej. Písmená B, C, I znamenajú zase BYTE, CARD, INT.

InputS je procedúra: text uloží do premennej, ktorú jej dáš v zátvorkách. Na text nestačí BYTE ani CARD – treba miesto pre viac znakov:

CHAR ARRAY name(40)

To je pole znakov s miestom pre 40 bajtov: jeden si Action! vezme na dĺžku textu, ostane 39 znakov. Poliam a reťazcom sa venujú kapitoly 18 a 19; tu stačí vedieť, že takto sa deklaruje premenná na text a že sa dá vypísať cez Print(name).

Celý program#

Súbor examples/input.act:

; A program that asks

PROC Main()
  CHAR ARRAY name(40)        ; room for a text of up to 39 characters
  BYTE age
  CARD year

  Print("What is your name? ")
  InputS(name)

  Print("How old are you? ")
  age=InputB()

  Print("What year is it? ")
  year=InputC()

  PutE()
  Print("Hello, ")
  Print(name)
  PrintE("!")

  Print("You were born in ")
  PrintC(year-age)
  PrintE(" or the year before.")
RETURN

Preklad a spustenie#

action26 input.act --sim

V simulátore píšeš odpovede na klávesnici svojho počítača. V emulátore (--run) na klávesnici Atari.

Čo uvidíš#

Program sa trikrát opýta. To, čo píšeš ty, je v ukážke za otáznikom:

What is your name? Pedro
How old are you? 12
What year is it? 2026

Hello, Pedro!
You were born in 2014 or the year before.

Ako to funguje#

• Print("What is your name? ") vypíše otázku a nechá kurzor na riadku, aby sa odpoveď písala hneď za ňu. Preto tu nie je PrintE.
• InputS(name) počká na riadok textu a uloží ho do name.
• age=InputB() počká na riadok, prevedie ho na číslo a uloží do age. Prázdne zátvorky za InputB sú povinné – je to volanie funkcie.
• PrintC(year-age) ukazuje, že do zátvoriek rutiny nemusí ísť len premenná: môže tam byť celý výraz. year je CARD, takže výsledok je CARD a patrí do PrintC.

Časté chyby#

Rutiny vstupu nekontrolujú, čo používateľ napísal. Číselný vstup číta číslice, kým nenarazí na iný znak: 12abc dá 12, abc dá 0.

Pole na text rob radšej väčšie. Riadok na obrazovke Atari má 40 znakov, ale používateľ môže písať ďalej – jeden vstup môže mať až 120 znakov. Kto chce mať istotu, použije CHAR ARRAY name(121).

Vyskúšaj si#

1. Pridaj otázku na obľúbené číslo a vypíš jeho dvojnásobok.
2. Načítaj dve čísla a vypíš ich súčet, rozdiel, súčin a podiel.
3. Zmeň age=InputB() na age=InputI() a zadaj záporný vek. Čo vypíše program a prečo? (Premenná age je BYTE.)

Zhrnutie#

• InputB(), InputC(), InputI() vrátia číslo napísané na klávesnici.
• InputS(pole) uloží napísaný text do poľa znakov.
• Otázku píš cez Print, nie PrintE, aby odpoveď stála za ňou.
• Vstup sa nekontroluje: zlé číslo je 0, pridlhý text prepíše pamäť.

Späť: 7. Počítanie · Ďalej: 9. Podmienka

9. Podmienka: IF, THEN, ELSEIF, ELSE, FI#

Na čo to je#

Program sa rozhoduje: niektoré príkazy vykoná, len keď niečo platí. „Ak je skóre viac ako rekord, vypíš gratuláciu.“

Ako sa to píše#

Najkratší tvar:

IF podmienka THEN
  príkazy            ; vykonajú sa, len keď podmienka platí
FI

Plný tvar:

IF podmienka THEN
  príkazy            ; keď platí prvá podmienka
ELSEIF iná podmienka THEN
  príkazy            ; keď prvá neplatí a druhá áno
ELSE
  príkazy            ; keď neplatí žiadna
FI

ELSEIF a ELSE sú nepovinné. FI je povinné vždy.

Porovnania#

Znak = má v Action! dve úlohy. V príkaze x=5 je to priradenie, za IF je to porovnanie. Prekladač to spozná podľa miesta.

Spájanie podmienok#

Celý program#

Súbor examples/if.act:

; Decisions

PROC Main()
  BYTE age

  Print("How old are you? ")
  age=InputB()
  PutE()

  IF age<6 THEN
    PrintE("You do not go to school yet.")
  ELSEIF age<15 THEN
    PrintE("You go to primary school.")
  ELSEIF age<19 THEN
    PrintE("You go to secondary school.")
  ELSE
    PrintE("You are grown up.")
  FI

  IF age>=13 AND age<=19 THEN
    PrintE("You are a teenager.")
  FI

  IF age=0 OR age>120 THEN
    PrintE("Is that really your age?")
  FI

  IF age#18 THEN
    PrintE("You are not 18.")
  FI
RETURN

Preklad a spustenie#

action26 if.act --sim

Čo uvidíš#

Po zadaní čísla 14:

How old are you? 14

You go to primary school.
You are a teenager.
You are not 18.

Spusti program viackrát s rôznym vekom (3, 14, 17, 18, 40, 200) a sleduj, ktoré riadky sa vypíšu.

Ako to funguje#

Prvý IF je reťaz. Podmienky sa skúšajú zhora nadol a vykoná sa len prvá vetva, ktorá platí. Pri veku 14 neplatí age<6, platí age<15 – vypíše sa „primary school“ a ostatné vetvy sa preskočia, hoci aj age<19 by platilo. Preto v druhej vetve netreba písať age>=6 AND age<15: keby bol vek menší ako 6, program by sa sem nedostal.

Ďalšie tri IF sú samostatné. Každý sa vyhodnotí zvlášť, takže sa môžu vypísať aj všetky.

age>=13 AND age<=19 je spôsob, ako zapísať „medzi 13 a 19“. Matematický zápis 13<=age<=19 Action! nepozná.

Časté chyby#

Dve veci, ktoré prekladač nehlási:

• AND má prednosť pred OR. a=5 OR a=6 AND b=7 znamená a=5 OR (a=6 AND b=7). Keď miešaš AND a OR, daj zátvorky – aj tam, kde nie sú nutné, pomôžu čitateľovi.
• Podmienka bez porovnania. IF lives THEN platí, keď lives nie je nula. Je to dovolené a používa sa to, ale začiatočníkovi sa odporúča písať porovnanie celé: IF lives>0 THEN.

Vyskúšaj si#

1. Pridaj vetvu pre vek presne 18: „You have just come of age.“
2. Načítaj dve čísla a vypíš väčšie z nich. Čo vypíšeš, keď sú rovnaké?
3. Načítaj číslo a vypíš, či je párne alebo nepárne. (Pomôže MOD z kapitoly 7.)

Zhrnutie#

• IF podmienka THEN … FI vykoná príkazy, len keď podmienka platí.
• ELSEIF pridá ďalšiu podmienku, ELSE vetvu „inak“.
• Z reťaze IF … ELSEIF … ELSE sa vykoná vždy najviac jedna vetva.
• Porovnania: =, # (alebo <>), <, >, <=, >=.
• AND – obe, OR – aspoň jedna. AND má prednosť.

Späť: 8. Vstup · Ďalej: 10. Slučka

10. Slučka: DO, OD, EXIT#

Na čo to je#

Počítač vie robiť tú istú vec znova a znova bez únavy. Slučka (cyklus) je kus programu, ktorý sa opakuje.

Ako sa to píše#

DO
  príkazy
OD

Samotné DO … OD sa opakuje donekonečna. Aby slučka niekedy skončila, treba v nej EXIT – zvyčajne v podmienke.

DO a OD sú základ všetkých slučiek v Action!. Slučky WHILE, UNTIL a FOR z ďalších kapitol sú to isté DO … OD s pridaným pravidlom, kedy skončiť.

Celý program#

Súbor examples/do.act:

; A loop: add numbers until the user enters 0

PROC Main()
  CARD sum, number

  sum=0
  PrintE("Enter numbers, 0 ends.")
  DO
    Print("? ")
    number=InputC()
    IF number=0 THEN
      EXIT
    FI
    sum==+number
  OD

  PutE()
  Print("The sum is ")
  PrintCE(sum)
RETURN

Preklad a spustenie#

action26 do.act --sim

Čo uvidíš#

Po zadaní čísel 12, 30, 8 a 0:

Enter numbers, 0 ends.
? 12
? 30
? 8
? 0

The sum is 50

Ako to funguje#

1. sum=0 – súčet začína na nule. Bez tohto riadka by v premennej mohlo byť čokoľvek.
2. Slučka vypíše otáznik a načíta číslo.
3. Ak je číslo 0, EXIT slučku ukončí a program pokračuje za OD.
4. Inak sa číslo pripočíta k súčtu (sum==+number) a OD vráti program na DO.

Príkazy medzi DO a OD sa volajú telo slučky. Odsadzujú sa, aby bolo vidieť, čo sa opakuje.

Slučka v slučke#

Keď je slučka vnútri inej slučky, EXIT ukončí len tú najbližšiu – tú, v ktorej priamo stojí. Vonkajšia beží ďalej.

Časté chyby#

Nekonečná slučka nie je chyba prekladu – niekedy ju chceš (hra beží, kým ju niekto nevypne). Keď sa ti to stane omylom:

• v simulátore sa program po chvíli zastaví sám a vypíše simulation stopped: instruction limit reached. Simulátor má poistku – po desiatich miliónoch inštrukcií skončí. Kým čaká na vstup z klávesnice, zastavíš ho klávesmi Ctrl+C;
• v emulátore zatvor okno alebo stlač kláves, ktorým emulátor resetuje Atari.

Vyskúšaj si#

1. Uprav program, aby popri súčte počítal, koľko čísel si zadal, a vypíš aj počet.
2. Uprav ho, aby skončil pri čísle 999 namiesto 0.
3. Vypíš na konci aj priemer (súčet delený počtom). Čo treba ošetriť, keď používateľ zadá hneď nulu?

Zhrnutie#

• DO … OD opakuje príkazy medzi nimi.
• EXIT slučku ukončí; bez neho beží donekonečna.
• EXIT ukončí len najbližšiu slučku.
• Pred slučkou nastav premenné, ktoré v nej počítaš (súčet, počítadlo), na začiatočnú hodnotu.

Späť: 9. Podmienka · Ďalej: 11. Slučka s podmienkou na začiatku

11. Slučka s podmienkou na začiatku: WHILE#

Na čo to je#

Väčšina slučiek má jasné pravidlo, dokedy bežať: „kým je hodnota menšia ako tisíc“. WHILE ho zapíše priamo, bez IF a EXIT.

Ako sa to píše#

WHILE podmienka
DO
  príkazy
OD

WHILE znamená „kým“. Pred každým prechodom slučkou sa podmienka vyhodnotí:

• platí → vykoná sa telo slučky a program sa vráti na WHILE,
• neplatí → slučka končí a program pokračuje za OD.

Podmienka je taká istá ako pri IF (kapitola 9).

Je to skratka za:

DO
  IF podmienka neplatí THEN EXIT FI
  príkazy
OD

Celý program#

Súbor examples/while.act:

; WHILE: the condition is tested before each turn

PROC Main()
  CARD value
  BYTE count

  value=1
  count=0
  WHILE value<1000
  DO
    PrintC(value) Put(' )
    value==*2
    count==+1
  OD
  PutE()
  Print("Doubled ") PrintB(count) PrintE(" times.")

  count=10
  WHILE count>20
  DO
    PrintE("This line is never written.")
  OD
  PrintE("Done.")
RETURN

Preklad a spustenie#

action26 while.act --sim

Čo uvidíš#

1 2 4 8 16 32 64 128 256 512 
Doubled 10 times.
Done.

Ako to funguje#

Prvá slučka zdvojnásobuje value, kým je menšie ako 1000. Vypíše 1, 2, 4 … 512. Po poslednom zdvojnásobení je value 1024, podmienka value<1000 prestane platiť a slučka skončí. Číslo 1024 sa už nevypíše – test je pred výpisom.

Druhá slučka sa nevykoná ani raz. count je 10, podmienka count>20 neplatí hneď na začiatku, a tak program telo preskočí. To je hlavná vlastnosť WHILE: telo sa nemusí vykonať vôbec.

V tele slučky sa musí meniť niečo, od čoho podmienka závisí. Keby v prvej slučke chýbalo value==*2, podmienka by platila navždy.

EXIT funguje aj vo WHILE – slučku ukončí predčasne.

Časté chyby#

Pozor na pretečenie (kapitola 7): keby value bolo BYTE, po 128 by nasledovalo 0 (256 sa do bajtu nezmestí), 0*2 je stále 0 a value<1000 platí vždy. Slučka by sa nikdy neskončila.

Vyskúšaj si#

1. Zmeň hranicu z 1000 na 50000. Koľkokrát sa hodnota zdvojnásobí?
2. Napíš odpočítavanie: vypíš čísla od 10 po 1 a potom Start!. (Premenná začína na 10 a v tele sa zmenšuje o 1.)
3. Načítaj číslo a vypíš, koľkokrát sa dá deliť dvoma, kým neklesne na 0.

Zhrnutie#

• WHILE podmienka DO … OD opakuje telo, kým podmienka platí.
• Podmienka sa skúša pred každým prechodom – telo sa nemusí vykonať ani raz.
• V tele musí byť niečo, čo podmienku časom zmení.

Späť: 10. Slučka · Ďalej: 12. Slučka s podmienkou na konci

12. Slučka s podmienkou na konci: UNTIL#

Na čo to je#

Niekedy treba telo slučky vykonať najprv a až potom zistiť, či ho opakovať. Typický prípad: opýtať sa, a ak odpoveď nevyhovuje, opýtať sa znova.

Ako sa to píše#

DO
  príkazy
UNTIL podmienka
OD

UNTIL znamená „až kým“. Stojí tesne pred OD. Po každom prechode telom sa podmienka vyhodnotí:

• platí → slučka končí,
• neplatí → program sa vráti na DO.

Dva rozdiely oproti WHILE:

Je to skratka za:

DO
  príkazy
  IF podmienka THEN EXIT FI
OD

Celý program#

Súbor examples/until.act:

; UNTIL: the condition is tested after each turn

PROC Main()
  BYTE number

  DO
    Print("Enter a number from 1 to 10: ")
    number=InputB()
  UNTIL number>=1 AND number<=10
  OD

  PutE()
  Print("Thank you, you entered ")
  PrintBE(number)
RETURN

Preklad a spustenie#

action26 until.act --sim

Čo uvidíš#

Po zadaní 0, potom 25 a nakoniec 7:

Enter a number from 1 to 10: 0
Enter a number from 1 to 10: 25
Enter a number from 1 to 10: 7

Thank you, you entered 7

Ako to funguje#

Program sa opýta, načíta číslo a až potom skúša, či je medzi 1 a 10. Ak nie, opýta sa znova. Za slučkou má program istotu, že number je v poriadku – inak by sa cez UNTIL nedostal.

Tu je UNTIL prirodzenejšie ako WHILE: pred prvou otázkou ešte žiadne číslo nie je, takže podmienku na začiatku nie je s čím vyhodnotiť.

Všimni si podmienku: hovorí, kedy slučka skončí („až kým je číslo medzi 1 a 10“), nie kedy pokračuje.

Časté chyby#

Na druhý riadok tabuľky pozor zvlášť. Ak prepisuješ WHILE na UNTIL, podmienku treba obrátiť: z < sa stane >=, z AND sa stane OR a naopak.

Vyskúšaj si#

1. Zmeň rozsah na 50 až 100.
2. Pridaj za InputB() výpis Wrong, try again., ktorý sa objaví, len keď číslo nevyhovuje. (Treba IF v tele slučky.)
3. Prepíš slučku pomocou WHILE. Čo musíš spraviť pred slučkou, aby fungovala?

Zhrnutie#

• DO … UNTIL podmienka OD opakuje telo, až kým podmienka začne platiť.
• Telo sa vykoná vždy aspoň raz.
• UNTIL stojí tesne pred OD.
• Podmienka hovorí, kedy skončiť – opačne ako pri WHILE.

Späť: 11. Slučka s podmienkou na začiatku · Ďalej: 13. Slučka s počítadlom

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

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
DO
  príkazy
OD

alebo s krokom:

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

Je to skratka za:

premenná=začiatok
WHILE premenná<=koniec
DO
  príkazy
  premenná==+krok
OD

Celý program#

Súbor examples/for.act:

; FOR: a loop with a counter

PROC Main()
  BYTE i, row, col

  FOR i=1 TO 10
  DO
    PrintB(i) Put(' )
  OD
  PutE()

  FOR i=0 TO 20 STEP 5
  DO
    PrintB(i) Put(' )
  OD
  PutE()

  PutE()
  PrintE("The 7 times table:")
  FOR row=1 TO 10
  DO
    PrintB(row) Print(" x 7 = ") PrintBE(row*7)
  OD

  PutE()
  FOR row=1 TO 4
  DO
    FOR col=1 TO row
    DO
      Put('*)
    OD
    PutE()
  OD
RETURN

Preklad a spustenie#

action26 for.act --sim

Čo uvidíš#

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

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

*
**
***
****

Ako to funguje#

• Prvá slučka: i ide od 1 do 10 vrátane. Počítadlo sa dá v tele normálne používať – tu sa vypisuje.
• Druhá slučka: STEP 5 zväčšuje i po piatich: 0, 5, 10, 15, 20.
• Násobilka: počítadlo row vstupuje do výpočtu row*7.
• Trojuholník: 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.

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.

Tri vlastnosti, ktoré treba poznať#

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

2. FOR nepočíta nadol. FOR i=10 TO 1 sa nevykoná ani raz, lebo 10 je už na začiatku väčšie ako koniec. Nepomôže ani STEP -1. Na odpočítavanie použi WHILE:

i=10
WHILE i>0
DO
  PrintBE(i)
  i==-1
OD

3. BYTE počítadlo a koniec 255 je nekonečná slučka.

BYTE i
FOR i=0 TO 255     ; never ends
DO
OD

Slučka končí, keď je počítadlo väčšie ako koniec. BYTE však väčší ako 255 byť nemôže – po 255 sa pretočí na 0 a ide sa odznova. Ak potrebuješ prejsť všetkých 256 hodnôt, použi počítadlo typu CARD.

Časté chyby#

Po skončení slučky má počítadlo hodnotu o krok väčšiu ako koniec: po FOR i=1 TO 3 je v i číslo 4.

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; výsledok môže byť až 100, to sa do BYTE zmestí.)
3. Sčítaj čísla od 1 do 100 a vypíš súčet. Akého typu musí byť premenná na súčet?

Zhrnutie#

• FOR i=a TO b DO … OD vykoná telo pre i od a po b vrátane.
• STEP n mení krok; bez neho je 1.
• Koniec a krok sa vyhodnotia raz na začiatku.
• FOR počíta len nahor.
• BYTE počítadlo nikdy neprekročí 255 – slučka TO 255 neskončí.

Späť: 12. Slučka s podmienkou na konci · Ďalej: 14. Parametre

14. Parametre: procedúra, ktorá dostane údaje#

Na čo to je#

Procedúra Line z kapitoly 3 vedela nakresliť čiaru len jednej dĺžky. S parametrom jej pri každom volaní povieš, akú dlhú. Jedna procedúra tak zvládne veľa podobných úloh.

Ako sa to píše#

Deklarácia:

PROC Meno(TYP parameter, parameter, TYP parameter)

Volanie:

Meno(hodnota, hodnota, hodnota)

• Parametre sa deklarujú v zátvorkách rovnako ako premenné: typ a meno. Viac parametrov toho istého typu stačí oddeliť čiarkou – BYTE width, height.
• Pri volaní dáš do zátvoriek argumenty: čísla, premenné alebo celé výrazy. Prvý argument ide do prvého parametra, druhý do druhého a tak ďalej.
• Vnútri procedúry sa parameter používa ako obyčajná premenná.
• Procedúra môže mať najviac 8 parametrov.

Celý program#

Súbor examples/params.act:

; Procedures with parameters

PROC Stars(BYTE count)
  BYTE i

  FOR i=1 TO count
  DO
    Put('*)
  OD
  PutE()
RETURN

PROC Box(BYTE width, height, CHAR c)
  BYTE x, y

  FOR y=1 TO height
  DO
    FOR x=1 TO width
    DO
      Put(c)
    OD
    PutE()
  OD
RETURN

PROC Change(BYTE value)
  value=99                   ; changes only the copy
RETURN

PROC Main()
  BYTE n

  Stars(5)
  Stars(12)

  n=3
  Stars(n*2)
  PutE()

  Box(8, 3, '#)
  PutE()

  Change(n)
  Print("n is still ")
  PrintBE(n)
RETURN

Preklad a spustenie#

action26 params.act --sim

Čo uvidíš#

*****
************
******

########
########
########

n is still 3

Ako to funguje#

• Stars(5) zavolá procedúru a do parametra count uloží 5. Slučka potom vypíše päť hviezdičiek.
• Stars(n*2) ukazuje, že argument môže byť výraz. Najprv sa vypočíta (3 × 2 = 6) a výsledok sa odovzdá.
• Box(8, 3, '#) má tri argumenty pre tri parametre: šírku, výšku a znak.
• Premenná i v Stars a x, y v Box sú deklarované vnútri procedúry. Patria len jej – viac v kapitole 16.

Procedúra dostane kópiu#

Change(n) odovzdá procedúre hodnotu premennej n, nie premennú samotnú. Parameter value je vlastná premenná procedúry, do ktorej sa trojka skopíruje. Keď ju procedúra prepíše na 99, n v Main sa nezmení.

Ak má procedúra zmeniť premennú volajúceho, treba jej odovzdať adresu premennej – to je téma kapitoly 20. Častejšie stačí, aby rutina výsledok vrátila; to vie funkcia z nasledujúcej kapitoly.

Časté chyby#

Menej argumentov Action! dovoľuje a niektoré staršie programy to využívajú. Ak chceš, aby ťa prekladač na to upozornil, pridaj voľbu --wextra:

action26 params.act --wextra

Potom pri Stars() vypíše warning ACT213: 'Stars' takes 1 argument(s), got 0.

Vyskúšaj si#

1. Pridaj procedúre Stars druhý parameter – znak, ktorý sa má vypisovať.
2. Napíš procedúru Triangle(BYTE size), ktorá vypíše trojuholník z hviezdičiek s daným počtom riadkov. Môže volať Stars.
3. Zavolaj Box(3, 8, 'O) a potom Box('O, 3, 8). Prečo druhé volanie vypíše niečo celkom iné?

Zhrnutie#

• Parametre sa deklarujú v zátvorkách za menom procedúry, s typom.
• Pri volaní sa argumenty priraďujú parametrom podľa poradia.
• Argument môže byť číslo, premenná aj výraz.
• Procedúra pracuje s kópiou – premennú volajúceho nezmení.
• Počet argumentov prekladač kontroluje len nahor; --wextra upozorní aj na chýbajúce.

Späť: 13. Slučka s počítadlom · Ďalej: 15. Funkcie

15. Funkcie: FUNC a RETURN(hodnota)#

Na čo to je#

Procedúra niečo spraví. Funkcia niečo vypočíta a vráti – jej volanie sa dá napísať všade, kde môže stáť číslo. Poznáš ich už z knižnice: InputB() je funkcia.

Ako sa to píše#

TYP FUNC Meno(parametre)
  príkazy
RETURN(výsledok)

Zátvorky za RETURN sú vo funkcii povinné. RETURN môže byť vo funkcii aj viackrát – vykoná sa ten, ku ktorému program dôjde prvý.

Volanie funkcie sa píše do výrazu:

x=Max(a, b)
PrintBE(Max(7, 12))
IF IsEven(n)=1 THEN … FI

Celý program#

Súbor examples/func.act:

; Functions: routines that give back a value

BYTE FUNC Max(BYTE a, b)
  IF a>b THEN
    RETURN(a)
  FI
RETURN(b)

CARD FUNC Square(CARD n)
RETURN(n*n)

BYTE FUNC IsEven(CARD n)
  IF n MOD 2=0 THEN
    RETURN(1)
  FI
RETURN(0)

PROC Main()
  CARD i, sum

  Print("The bigger of 7 and 12: ")
  PrintBE(Max(7, 12))

  Print("12 squared: ")
  PrintCE(Square(12))

  sum=0
  FOR i=1 TO 10
  DO
    sum==+Square(i)
  OD
  Print("Squares of 1 to 10 added: ")
  PrintCE(sum)

  FOR i=1 TO 4
  DO
    PrintC(i)
    IF IsEven(i)=1 THEN
      PrintE(" is even")
    ELSE
      PrintE(" is odd")
    FI
  OD
RETURN

Preklad a spustenie#

action26 func.act --sim

Čo uvidíš#

The bigger of 7 and 12: 12
12 squared: 144
Squares of 1 to 10 added: 385
1 is odd
2 is even
3 is odd
4 is even

Ako to funguje#

• Max má dva RETURN. Ak je a väčšie, funkcia skončí hneď prvým a vráti a. Inak program dôjde až na koniec a vráti b.
• Square je celá na jednom riadku: vypočíta n*n a vráti to.
• IsEven vracia 1 alebo 0 ako „áno“ a „nie“. Action! nemá zvláštny typ pre pravdu a nepravdu, používa sa číslo: 0 je nie, čokoľvek iné áno.
• PrintBE(Max(7, 12)) – najprv sa zavolá Max, jej výsledok (12) sa stane argumentom PrintBE.
• sum==+Square(i) – volanie funkcie vo výraze, v slučke desaťkrát.

Funkcia má tú výhodu, že volajúci nemusí vedieť, ako výsledok vznikol. Keď raz Max funguje, používaš ju ako hotovú súčiastku.

Procedúra alebo funkcia?#

Spoločné slovo pre procedúry a funkcie je rutina.

Časté chyby#

Funkciu možno zavolať aj ako procedúru (Max(1, 2) na vlastnom riadku). Výsledok sa vtedy zahodí. Pri Max to nemá zmysel; pri funkcii, ktorá okrem výsledku aj niečo robí, niekedy áno.

Typ funkcie rozhoduje o tom, čo sa vráti. BYTE FUNC, ktorá vráti 300, vráti 44.

Vyskúšaj si#

1. Napíš BYTE FUNC Min(BYTE a, b) a vypíš menšie z dvoch čísel.
2. Napíš CARD FUNC Power(CARD base, BYTE exponent), ktorá vypočíta mocninu opakovaným násobením v slučke.
3. Použi Max na nájdenie najväčšieho z troch čísel: Max(Max(a, b), c).

Zhrnutie#

• TYP FUNC Meno(…) je rutina, ktorá vracia hodnotu.
• RETURN(hodnota) – so zátvorkami – funkciu ukončí a hodnotu vráti.
• Volanie funkcie môže stáť vo výraze, v podmienke aj ako argument inej rutiny.
• „Áno“ a „nie“ sa vracia ako 1 a 0.

Späť: 14. Parametre · Ďalej: 16. Kde premenná platí

16. Kde premenná platí: lokálne, globálne, MODULE#

Na čo to je#

Doteraz si premenné deklaroval vnútri procedúry. Taká premenná patrí len tej procedúre. Keď má hodnotu vidieť viac rutín – skóre, počet životov – deklaruje sa mimo rutín.

Ako sa to píše#

BYTE score              ; globálna: pred prvou rutinou

PROC Something()
  BYTE helper           ; lokálna: na začiatku rutiny
  …
RETURN

MODULE                  ; dovolí ďalšie globálne deklarácie za rutinou
BYTE lives

PROC Main()
  …
RETURN

MODULE je potrebné, keď chceš deklarovať globálne premenné až za nejakou rutinou. Bez neho by prekladač ohlásil, že deklarácie musia byť pred príkazmi.

Celý program#

Súbor examples/scope.act:

; Where a variable lives

BYTE score=[0]               ; global: every routine below sees it

PROC AddPoints(BYTE points)
  BYTE bonus                 ; local: only AddPoints sees it

  bonus=points/10
  score==+points+bonus
RETURN

PROC Counter()
  BYTE calls=[0]             ; a local keeps its value between calls

  calls==+1
  Print("Counter was called ")
  PrintB(calls)
  PrintE(" times")
RETURN

PROC Hide()
  BYTE score                 ; a local with the name of a global hides it

  score=200
  Print("Inside Hide: ")
  PrintBE(score)
RETURN

MODULE                       ; global declarations after a routine need MODULE
BYTE lives=[3]

PROC Main()
  AddPoints(20)
  AddPoints(50)
  Print("Score: ")
  PrintBE(score)

  Counter()
  Counter()
  Counter()

  Hide()
  Print("Score after Hide: ")
  PrintBE(score)

  Print("Lives: ")
  PrintBE(lives)
RETURN

Preklad a spustenie#

action26 scope.act --sim

Čo uvidíš#

Score: 77
Counter was called 1 times
Counter was called 2 times
Counter was called 3 times
Inside Hide: 200
Score after Hide: 77
Lives: 3

Ako to funguje#

• score je globálna. AddPoints ju mení, Main ju vypisuje – obe pracujú s tou istou premennou. Po dvoch volaniach je v nej 20 + 2 + 50 + 5 = 77.
• bonus je lokálna. Mimo AddPoints neexistuje; keby si ju použil v Main, prekladač ohlási neznáme meno.
• calls v Counter si pamätá hodnotu medzi volaniami. To je zvláštnosť Action!, o ktorej je ďalšia časť.
• score v Hide je iná premenná. Lokálna premenná s rovnakým menom globálnu zakryje: vnútri Hide znamená score tú lokálnu. Globálna ostane nedotknutá – po návrate je v nej stále 77.
• lives je deklarovaná za MODULE a vidí ju len Main, lebo len tá je pod ňou.

Lokálne premenné nezanikajú#

V mnohých jazykoch lokálna premenná vznikne pri volaní rutiny a po návrate zmizne. V Action! má každá lokálna premenná svoje pevné miesto v pamäti po celý čas behu programu. Z toho plynú tri veci:

1. Hodnota prežije medzi volaniami. Counter to využíva: calls sa pri každom volaní zväčší a pamätá si to.
2. Počiatočná hodnota =[0] sa nastaví len raz – pri nahraní programu, nie pri každom volaní. Ak má premenná začínať pri každom volaní od nuly, priraď jej nulu príkazom (calls=0).
3. Rutina nesmie volať samu seba. Volanie rutiny zo seba samej (rekurzia) v Action! prepíše jej vlastné parametre a lokálne premenné, lebo existujú len raz. Program sa preloží, ale počíta zle. Namiesto rekurzie použi slučku.

Globálna alebo lokálna?#

• Lokálna, kedykoľvek sa dá. Počítadlo slučky, medzivýsledok – nikto iný ich nepotrebuje a nik iný ich omylom neprepíše.
• Globálna pre stav celého programu: skóre, životy, poloha hráča.

Časté chyby#

Zakrytie globálnej premennej lokálnou prekladač nehlási – je to dovolené. Keď sa ti „nemení“ globálna premenná, pozri, či si v rutine omylom nedeklaroval lokálnu s rovnakým menom.

Vyskúšaj si#

1. Použi bonus v Main a prečítaj si hlásenie prekladača.
2. Zmaž riadok MODULE a prelož. Čo sa stane?
3. Presuň deklaráciu lives na začiatok súboru k score. Potrebuješ ešte MODULE?

Zhrnutie#

• Globálna premenná je deklarovaná mimo rutín a vidia ju všetky rutiny pod ňou.
• Lokálna premenná a parameter patria jednej rutine.
• MODULE dovolí globálne deklarácie medzi rutinami.
• Lokálna premenná zakryje globálnu s rovnakým menom.
• Lokálne premenné v Action! nezanikajú: pamätajú si hodnotu a rekurzia nefunguje.

Späť: 15. Funkcie · Ďalej: 17. Mená pre čísla

17. Mená pre čísla: DEFINE#

Na čo to je#

Číslo 20 v programe nič nehovorí. WIDTH hovorí, že ide o šírku. DEFINE dá menu text, ktorým ho prekladač pri preklade nahradí. Keď sa šírka zmení, opravíš ju na jednom mieste.

Ako sa to píše#

DEFINE MENO="text"
DEFINE MENO1="text", MENO2="text"

• Text je vždy v úvodzovkách, aj keď je to číslo: DEFINE WIDTH="20".
• Viac mien naraz sa oddeľuje čiarkou. Deklarácia môže pokračovať na ďalšom riadku.
• Všade, kde prekladač v programe nájde MENO, dosadí namiesto neho text – ako keby si ho tam napísal sám.
• Mená z DEFINE sa zvyčajne píšu veľkými písmenami, aby sa odlíšili od premenných.

DEFINE nie je premenná. Nezaberá pamäť, nedá sa do neho nič priradiť a za behu programu neexistuje. Je to pokyn pre prekladač: „toto slovo čítaj ako tento text“.

Celý program#

Súbor examples/define.act:

; DEFINE: names for numbers and pieces of the program

DEFINE WIDTH="20",
       HEIGHT="4",
       FRAME="'#",
       STRING="CHAR ARRAY"

PROC Main()
  BYTE x, y
  STRING title="A box of WIDTH by HEIGHT"

  PrintE(title)
  FOR y=1 TO HEIGHT
  DO
    FOR x=1 TO WIDTH
    DO
      IF y=1 OR y=HEIGHT OR x=1 OR x=WIDTH THEN
        Put(FRAME)
      ELSE
        Put(' )
      FI
    OD
    PutE()
  OD

  Print("Characters in the box: ")
  PrintBE(WIDTH*HEIGHT)
RETURN

Preklad a spustenie#

action26 define.act --sim

Čo uvidíš#

A box of WIDTH by HEIGHT
####################
#                  #
#                  #
####################
Characters in the box: 80

Ako to funguje#

• WIDTH a HEIGHT sú čísla. FOR x=1 TO WIDTH prekladač číta ako FOR x=1 TO 20.
• FRAME je znak: Put(FRAME) je Put('#).
• STRING nahrádza dve slová naraz. STRING title=… je CHAR ARRAY title=…. Tento DEFINE je medzi programátormi v Action! bežný zvyk – nájdeš ho v mnohých starých programoch.
• V reťazcoch sa nenahrádza. Text "A box of WIDTH by HEIGHT" sa vypíše tak, ako je. Úvodzovky chránia svoj obsah.
• Podmienka y=1 OR y=HEIGHT OR x=1 OR x=WIDTH platí pre prvý a posledný riadok a prvý a posledný stĺpec – teda pre okraj.

Skús zmeniť WIDTH na 30 a HEIGHT na 6: rám, slučky aj výpočet počtu znakov sa prispôsobia samy.

Pasca: DEFINE je text, nie hodnota#

DEFINE SIZE="5+5"
…
PrintBE(SIZE*2)

Vyzerá to ako 10 × 2 = 20, ale vypíše sa 15. Prekladač dosadí text a číta 5+5*2 – a násobenie má prednosť. Keď je v DEFINE výpočet, daj ho do zátvoriek: DEFINE SIZE="(5+5)".

Časté chyby#

Kde DEFINE platí#

DEFINE na začiatku súboru platí do konca súboru. DEFINE napísaný vnútri rutiny platí len do konca tej rutiny.

Vyskúšaj si#

1. Zmeň rozmery škatule a znak rámu.
2. Pridaj DEFINE INSIDE="'." a vyplň ním vnútro škatule namiesto medzery.
3. Vyskúšaj pascu so SIZE – so zátvorkami aj bez nich.

Zhrnutie#

• DEFINE MENO="text" – prekladač všade nahradí meno textom.
• Text je vždy v úvodzovkách.
• Nezaberá pamäť a nedá sa meniť za behu.
• V reťazcoch sa nenahrádza.
• Výpočet v DEFINE patrí do zátvoriek.

Späť: 16. Kde premenná platí · Ďalej: 18. Polia

18. Polia: ARRAY#

Na čo to je#

Dvanásť mesiacov, sto nepriateľov, tisíc bodov obrazovky – na to nechceš dvanásť, sto ani tisíc premenných. Pole je rad hodnôt rovnakého typu pod jedným menom. Jednotlivé hodnoty (prvky) sa rozlišujú číslom – indexom.

Ako sa to píše#

Deklarácia:

BYTE ARRAY scores(10)              ; 10 prvkov typu BYTE
CARD ARRAY squares(10)             ; 10 prvkov typu CARD
INT  ARRAY heights(50)             ; 50 prvkov typu INT
BYTE ARRAY days=[31 28 31 30]      ; pole s hodnotami; veľkosť sa spočíta sama

Použitie prvku:

scores(0)=100        ; zápis do prvého prvku
x=scores(3)          ; čítanie štvrtého prvku
scores(i)=scores(i)+1

• Číslo v zátvorke pri deklarácii je počet prvkov.
• Indexy idú od 0. Pole s 10 prvkami má prvky (0) až (9). Prvok (10) neexistuje.
• Index môže byť číslo, premenná aj výraz.
• Počiatočné hodnoty sa píšu do hranatých zátvoriek a oddeľujú sa medzerami (čiarky medzi nimi prekladač tiež prijme).

Celý program#

Súbor examples/arrays.act:

; Arrays: many values under one name

PROC Main()
  BYTE ARRAY days=[31 28 31 30 31 30 31 31 30 31 30 31]
  CARD ARRAY squares(10)     ; 10 elements: squares(0) to squares(9)
  BYTE i, biggest
  CARD total

  FOR i=0 TO 9               ; fill the array in a loop
  DO
    squares(i)=i*i
  OD

  Print("Squares: ")
  FOR i=0 TO 9
  DO
    PrintC(squares(i)) Put(' )
  OD
  PutE()

  Print("Days in March: ")
  PrintBE(days(2))           ; January is days(0)

  total=0
  FOR i=0 TO 11
  DO
    total==+days(i)
  OD
  Print("Days in a year: ")
  PrintCE(total)

  days(1)=29                 ; an element can be changed
  Print("February in a leap year: ")
  PrintBE(days(1))

  biggest=0
  FOR i=0 TO 11
  DO
    IF days(i)>biggest THEN
      biggest=days(i)
    FI
  OD
  Print("The longest month has ")
  PrintB(biggest)
  PrintE(" days")
RETURN

Preklad a spustenie#

action26 arrays.act --sim

Čo uvidíš#

Squares: 0 1 4 9 16 25 36 49 64 81 
Days in March: 31
Days in a year: 365
February in a leap year: 29
The longest month has 31 days

Ako to funguje#

Pole a slučka FOR patria k sebe: počítadlo slučky je index.

• Naplnenie: squares(i)=i*i pre i od 0 do 9.
• Výpis: tá istá slučka, len sa prvok číta.
• Súčet: pred slučkou total=0, v slučke total==+days(i).
• Hľadanie najväčšieho: biggest začne na 0 a každý prvok, ktorý je väčší, ho nahradí.

days(2) je marec, nie február – január má index 0. Posun o jednotku je najčastejší zdroj chýb pri poliach.

Pole ako parameter#

Rutina môže dostať pole. V parametri sa píše bez veľkosti:

PROC Fill(BYTE ARRAY a, BYTE count)
  BYTE i

  FOR i=0 TO count-1
  DO
    a(i)=i*2
  OD
RETURN

Volanie: Fill(scores, 10). Na rozdiel od obyčajnej premennej (kapitola 14) sa pole nekopíruje – rutina pracuje priamo s poľom volajúceho a zmeny v ňom ostanú. Veľkosť poľa rutina nepozná, preto sa odovzdáva zvlášť.

Najväčšie nebezpečenstvo: index mimo poľa#

Action! nekontroluje, či je index v rozsahu poľa. Zápis za koniec poľa prepíše to, čo leží v pamäti za ním – zvyčajne iné premenné:

BYTE ARRAY a(3)
BYTE x

x=7
a(3)=9          ; a má len prvky 0, 1, 2
PrintBE(x)      ; vypíše 9

Prekladač nič nehlási, program beží a chyba sa prejaví inde a neskôr. Keď sa premenná „sama“ mení, hľadaj pole pred ňou a slučku, ktorá ide o jeden prvok ďalej (TO 10 namiesto TO 9).

Časté chyby#

Prvky poľa bez počiatočných hodnôt nemusia byť nulové. Pred použitím ich naplň.

Vyskúšaj si#

1. Vypíš mesiace, ktoré majú 30 dní – ich čísla od 1 do 12, nie indexy.
2. Načítaj päť čísel do poľa a vypíš ich v opačnom poradí. (Odpočítavať treba cez WHILE, kapitola 13.)
3. Vypočítaj priemer prvkov poľa squares.

Zhrnutie#

• TYP ARRAY meno(počet) deklaruje pole; prvky sú meno(0) až meno(počet−1).
• TYP ARRAY meno=[h1 h2 h3] deklaruje pole s hodnotami.
• Pole sa spracúva slučkou FOR.
• Pole ako parameter sa nekopíruje.
• Index mimo poľa sa nekontroluje a prepíše inú pamäť.

Späť: 17. Mená pre čísla · Ďalej: 19. Reťazce

19. Reťazce: CHAR ARRAY#

Na čo to je#

Reťazec je text uložený v programe: meno hráča, hlásenie, riadok zo súboru. V Action! je to obyčajné pole znakov s jedným pravidlom navyše.

Ako sa to píše#

CHAR ARRAY name="Atari"      ; reťazec s textom
CHAR ARRAY buffer(40)        ; prázdne miesto pre reťazec: dĺžka + 39 znakov

Pravidlo: prvok (0) je dĺžka textu, znaky sú v prvkoch (1), (2) …

Z toho plynie, že reťazec môže mať najviac 255 znakov (viac sa do jedného bajtu dĺžky nezmestí) a že pole pre text s n znakmi potrebuje n+1 bajtov.

Knižnica má na reťazce štyri rutiny:

Celý program#

Súbor examples/strings.act:

; Strings: texts in CHAR ARRAYs

PROC Order(CHAR ARRAY a, b)  ; a string as a parameter
  INT result

  result=SCompare(a, b)
  Print(a)
  IF result<0 THEN
    Print(" comes before ")
  ELSEIF result=0 THEN
    Print(" is the same as ")
  ELSE
    Print(" comes after ")
  FI
  PrintE(b)
RETURN

PROC Main()
  CHAR ARRAY name="Atari"    ; a string with its text
  CHAR ARRAY copy(20), part(20), line(40)
  BYTE i

  Print("The text: ")      PrintE(name)
  Print("Its length: ")    PrintBE(name(0))
  Print("First letter: ")  Put(name(1)) PutE()

  Print("Spelled: ")
  FOR i=1 TO name(0)
  DO
    Put(name(i)) Put(' )
  OD
  PutE()

  SCopy(copy, name)          ; copy the whole string
  copy(1)='S                 ; change one character
  Print("Changed copy: ")  PrintE(copy)
  Print("The original: ")  PrintE(name)

  SCopyS(part, "Action! language", 1, 7)
  Print("A part: ")        PrintE(part)

  SCopy(line, "Hello, ")     ; join two strings
  SAssign(line, name, line(0)+1, line(0)+name(0))
  Print("Joined: ")        PrintE(line)

  Order("apple", "banana")
  Order("pear", "pear")
  Order("zebra", "ant")
RETURN

Preklad a spustenie#

action26 strings.act --sim

Čo uvidíš#

The text: Atari
Its length: 5
First letter: A
Spelled: A t a r i 
Changed copy: Stari
The original: Atari
A part: Action!
Joined: Hello, Atari
apple comes before banana
pear is the same as pear
zebra comes after ant

Ako to funguje#

• name(0) je dĺžka, name(1) prvý znak. Slučka FOR i=1 TO name(0) prejde všetky znaky – to je bežný spôsob, ako spracovať text znak po znaku.
• SCopy(copy, name) – cieľ je prvý, zdroj druhý. Tak je to pri všetkých rutinách na reťazce.
• copy(1)='S mení jeden znak ako prvok poľa. Originál name ostáva nedotknutý, lebo copy je vlastné pole.
• SCopyS(part, "Action! language", 1, 7) vyberie znaky 1 až 7. Zdrojom môže byť aj text priamo v úvodzovkách.
• Spojenie dvoch reťazcov Action! nemá ako jednu rutinu. Skladá sa zo SCopy (prvá časť) a SAssign (druhá časť za koniec prvej). line(0)+1 je prvá voľná pozícia; SAssign reťazec podľa potreby predĺži.
• SCompare porovnáva podľa abecedy – presnejšie podľa kódov znakov. Na presnej hodnote výsledku nezáleží, len na tom, či je záporný, nulový alebo kladný.

Procedúra Order ukazuje reťazec ako parameter: CHAR ARRAY a bez veľkosti. Ako každé pole sa nekopíruje.

Časté chyby#

Na porovnanie textov teda vždy SCompare(a, b)=0, nikdy a=b.

DEFINE STRING="CHAR ARRAY" z kapitoly 17 robí deklarácie reťazcov čitateľnejšími: STRING name(40).

Vyskúšaj si#

1. Načítaj meno cez InputS a vypíš ho odzadu.
2. Spočítaj, koľkokrát je v načítanom texte písmeno a.
3. Načítaj dve slová a vypíš ich v abecednom poradí.

Zhrnutie#

• Reťazec je CHAR ARRAY; prvok 0 je dĺžka, znaky sú od prvku 1.
• Pole pre n znakov musí mať aspoň n+1 bajtov.
• SCopy kopíruje, SCopyS vyberá časť, SAssign vkladá, SCompare porovnáva.
• Cieľ je vždy prvý parameter.
• Reťazce sa neporovnávajú znakom = a nepriraďujú znakom =.

Späť: 18. Polia · Ďalej: 20. Ukazovatele

20. Ukazovatele: POINTER, ^, @#

Na čo to je#

Každá premenná leží niekde v pamäti – na svojej adrese. Adresa je číslo od 0 do 65535, ako číslo domu na dlhej ulici. Ukazovateľ je premenná, v ktorej je adresa inej premennej. Cez ukazovateľ sa dá k tej premennej dostať, aj keď nepoznáš jej meno.

Hodí sa to v dvoch prípadoch: keď má rutina zmeniť premennú volajúceho, a keď sa prechádza pamäťou bajt po bajte.

Ako sa to píše#

BYTE POINTER p      ; ukazovateľ na BYTE
CARD POINTER q      ; ukazovateľ na CARD

Typ pred slovom POINTER hovorí, čo na danej adrese leží: BYTE POINTER číta a zapisuje jeden bajt, CARD POINTER dva.

Celý program#

Súbor examples/pointers.act:

; Pointers: variables that hold an address

PROC Swap(BYTE POINTER a, b)
  BYTE keep

  keep=a^
  a^=b^
  b^=keep
RETURN

PROC Main()
  BYTE x, y, i
  BYTE POINTER p
  BYTE ARRAY data=[5 8 13 21]

  x=10
  y=20

  p=@x                       ; p holds the address of x
  Print("p points at x: ")  PrintBE(p^)

  p^=15                      ; store through the pointer
  Print("x is now ")        PrintBE(x)

  p=@y                       ; the same pointer, another variable
  Print("p points at y: ")  PrintBE(p^)

  Swap(@x, @y)               ; the routine changes our variables
  Print("After Swap: x=")   PrintB(x)
  Print(" y=")              PrintBE(y)

  p=data                     ; the name of an array is its address
  Print("The array: ")
  FOR i=1 TO 4
  DO
    PrintB(p^) Put(' )
    p==+1                    ; move to the next byte
  OD
  PutE()
RETURN

Preklad a spustenie#

action26 pointers.act --sim

Čo uvidíš#

p points at x: 10
x is now 15
p points at y: 20
After Swap: x=20 y=15
The array: 5 8 13 21 

Ako to funguje#

• p=@x – v p je adresa premennej x. p^ je potom to isté ako x.
• p^=15 zapíše 15 na tú adresu. Keď potom vypíšeš x, je v ňom 15, hoci si do x priamo nič nepriradil.
• p=@y – ten istý ukazovateľ môže postupne ukazovať na rôzne premenné.

Rutina, ktorá mení premenné volajúceho#

Z kapitoly 14 vieš, že procedúra dostáva kópie. Swap má premenné vymeniť, takže kópie jej nestačia. Dostane preto ich adresy (Swap(@x, @y)) a cez a^ a b^ pracuje priamo s premennými x a y v Main.

Takto môže rutina „vrátiť“ viac hodnôt naraz.

Ukazovateľ a pole#

Meno poľa bez indexu je adresa jeho prvého prvku. Preto p=data (bez @) nastaví p na začiatok poľa. p==+1 potom posunie ukazovateľ o jeden bajt a slučka prejde pole bez indexov.

Platí to aj naopak: ukazovateľ sa dá indexovať ako pole, p(2) je bajt dva miesta za adresou v p.

Pole deklarované bez veľkosti a bez hodnôt (BYTE ARRAY a) je vlastne ukazovateľ: nemá vlastné prvky a treba mu najprv priradiť adresu.

Časté chyby#

Prekladač tieto chyby nehlási. Ukazovateľ je silný nástroj práve preto, že ti dovolí siahnuť kamkoľvek do pamäte – aj tam, kam nemáš.

Pri treťom riadku si pomôžeš indexom: q(1) pri CARD POINTER q je druhý CARD, index sa veľkosťou prvku násobí sám.

Vyskúšaj si#

1. Napíš procedúru Reset(BYTE POINTER p), ktorá vynuluje premennú, na ktorú dostane adresu.
2. Napíš procedúru MinMax(BYTE a, b, BYTE POINTER min, max), ktorá uloží menšie z dvoch čísel do min^ a väčšie do max^.
3. Prejdi pole data ukazovateľom a spočítaj súčet jeho prvkov.

Zhrnutie#

• Ukazovateľ je premenná s adresou inej premennej.
• @x je adresa x; p^ je hodnota na adrese v p.
• Rutina, ktorá dostane adresu, môže zmeniť premennú volajúceho.
• Meno poľa je adresa jeho začiatku.
• Ukazovateľ treba najprv nastaviť; chyby s ukazovateľmi prekladač nezachytí.

Späť: 19. Reťazce · Ďalej: 21. Záznamy

21. Záznamy: TYPE#

Na čo to je#

Hráč má polohu, počet životov a skóre. Sú to štyri premenné, ktoré patria k sebe. Záznam (record) ich spojí do jedného celku s vlastným menom, takže sa dajú odovzdať rutine naraz.

Ako sa to píše#

Najprv sa opíše typ záznamu – aké položky má:

TYPE Player=[BYTE x, y, lives
             CARD score]

• TYPE Meno=[ … ] – v hranatých zátvorkách sú položky, zapísané ako deklarácie premenných.
• Položky toho istého typu oddeľuje čiarka. Medzi skupinami typov sa čiarka nepíše – za lives nasleduje rovno CARD.
• Položky môžu byť len základných typov: BYTE, CHAR, CARD, INT.
• TYPE sa píše mimo rutín, na začiatok súboru.

Potom sa meno typu používa ako každý iný typ:

Player hero, enemy           ; dve premenné typu Player
Player POINTER who           ; ukazovateľ na záznam

hero.x=10                    ; položka sa píše za bodku
who.score==+100              ; cez ukazovateľ rovnako, bez ^

Celý program#

Súbor examples/records.act:

; Records: several values that belong together

TYPE Player=[BYTE x, y, lives
             CARD score]

PROC Show(Player POINTER who)
  Print("at ")      PrintB(who.x)
  Put(',)           PrintB(who.y)
  Print(" lives ")  PrintB(who.lives)
  Print(" score ")  PrintCE(who.score)
RETURN

PROC Hit(Player POINTER who, CARD points)
  who.score==+points
RETURN

PROC Main()
  Player hero, enemy

  hero.x=10
  hero.y=5
  hero.lives=3
  hero.score=0

  enemy.x=30
  enemy.y=12
  enemy.lives=1
  enemy.score=500

  Print("Hero:  ")  Show(hero)
  Print("Enemy: ")  Show(enemy)

  Hit(hero, 250)
  hero.x==+1
  Print("Hero:  ")  Show(hero)
RETURN

Preklad a spustenie#

action26 records.act --sim

Čo uvidíš#

Hero:  at 10,5 lives 3 score 0
Enemy: at 30,12 lives 1 score 500
Hero:  at 11,5 lives 3 score 250

Ako to funguje#

• Player hero, enemy vytvorí dva záznamy. Každý má vlastné x, y, lives a score.
• hero.x=10 zapíše do položky x záznamu hero.
• Záznam sa rutine odovzdáva cez ukazovateľ. Parameter je Player POINTER who. Pri volaní stačí napísať meno záznamu: Show(hero) – meno záznamu bez bodky je, podobne ako meno poľa, jeho adresa.
• Vnútri rutiny sa položky píšu rovnako: who.x. Znak ^ tu netreba.
• Hit(hero, 250) záznam mení. Keďže rutina dostala adresu, mení priamo hero v Main.

Jedna rutina Show obslúži hrdinu aj nepriateľa. To je hlavný zmysel záznamov: rutiny sa píšu pre typ, nie pre jednu konkrétnu premennú.

Pole záznamov#

Action! nemá Player ARRAY. Viac záznamov za sebou sa robí poľom bajtov a ukazovateľom, ktorý sa posúva o veľkosť záznamu. Meno typu vo výraze je veľkosť záznamu v bajtoch.

Súbor examples/records-array.act:

; An array of records: a block of bytes and a pointer that walks through it

TYPE Star=[BYTE x, y
           CARD points]

DEFINE COUNT="3"

PROC Main()
  BYTE ARRAY room(12)        ; room for COUNT records of 4 bytes
  Star POINTER s
  BYTE i

  FOR i=0 TO COUNT-1
  DO
    s=room+i*Star            ; the address of record number i
    s.x=i*10
    s.y=i+1
    s.points=(i+1)*100
  OD

  FOR i=0 TO COUNT-1
  DO
    s=room+i*Star
    Print("Star ")    PrintB(i)
    Print(": x=")     PrintB(s.x)
    Print(" y=")      PrintB(s.y)
    Print(" points=") PrintCE(s.points)
  OD

  Print("One record takes ")
  PrintB(Star)
  PrintE(" bytes")
RETURN

action26 records-array.act --sim

Star 0: x=0 y=1 points=100
Star 1: x=10 y=2 points=200
Star 2: x=20 y=3 points=300
One record takes 4 bytes

s=room+i*Star vypočíta adresu záznamu číslo i: začiatok poľa plus i-krát veľkosť záznamu. Záznam Star má dva BYTE a jeden CARD, teda 4 bajty; tri záznamy potrebujú 12 bajtov.

Časté chyby#

Mená položiek sú mená ako každé iné. Dva typy záznamov v jednom programe preto nemôžu mať položku s rovnakým menom – prekladač ohlási error ACT006: 'x' is already declared. Pomáha predpona: px, py pre hráča, sx, sy pre hviezdu.

Vyskúšaj si#

1. Pridaj do Player položku CHAR symbol a vypisuj ju v Show.
2. Napíš PROC Move(Player POINTER who, BYTE dx, dy), ktorá posunie hráča.
3. V druhom programe zmeň COUNT na 5. Čo ešte treba zmeniť?

Zhrnutie#

• TYPE Meno=[položky] opíše záznam; potom je Meno typ.
• Položka sa píše záznam.položka.
• Rutine sa záznam odovzdáva ako Meno POINTER; pri volaní stačí meno záznamu.
• Meno typu vo výraze je veľkosť záznamu.
• Pole záznamov = pole bajtov + ukazovateľ posúvaný o veľkosť záznamu.

Späť: 20. Ukazovatele · Ďalej: 22. Bity

22. Bity: &, %, !, LSH, RSH#

Na čo to je#

Bajt je osem bitov – ôsmich prepínačov, z ktorých každý je buď 0, alebo 1. Počítač Atari má veľa nastavení uložených tak, že každý bit bajtu znamená niečo iné: jeden zapína inverzné písmo, iný hovorí, či je stlačené tlačidlo. Bitové operácie dovolia pracovať s jednotlivými bitmi.

Kapitolu môžeš pri prvom čítaní preskočiť a vrátiť sa k nej, keď budeš bity potrebovať.

Dvojková sústava v skratke#

Každý bit má svoju hodnotu – mocninu dvojky. Bity sa číslujú sprava, od 0:

Číslo je súčet hodnôt bitov, ktoré sú 1. Napríklad 12 je 00001100: bit 3 (hodnota 8) a bit 2 (hodnota 4), 8 + 4 = 12.

Ako sa to píše#

Znak a slovo sú to isté: a & b je a AND b. Sú to tie isté AND a OR ako v podmienkach (kapitola 9) – tam spájajú porovnania, tu pracujú s bitmi čísel.

K čomu sa hodia:

Maska je číslo, ktoré má jednotky na bitoch, o ktoré ide.

Celý program#

Súbor examples/bits.act:

; Bits: looking inside a byte

PROC Bits(BYTE value)        ; write a byte as eight binary digits
  BYTE i, mask

  mask=128
  FOR i=1 TO 8
  DO
    IF value&mask THEN
      Put('1)
    ELSE
      Put('0)
    FI
    mask==RSH 1
  OD
RETURN

PROC Show(BYTE value)
  Bits(value)
  Print(" = ")
  PrintBE(value)
RETURN

PROC Main()
  BYTE a, b

  a=12
  b=10
  Print("a           ")  Show(a)
  Print("b           ")  Show(b)
  Print("a AND b     ")  Show(a&b)
  Print("a OR b      ")  Show(a%b)
  Print("a XOR b     ")  Show(a!b)
  Print("a LSH 1     ")  Show(a LSH 1)
  Print("a RSH 2     ")  Show(a RSH 2)

  a=5
  a==%128                    ; switch bit 7 on
  Print("bit 7 on    ")  Show(a)
  a==&127                    ; switch bit 7 off
  Print("bit 7 off   ")  Show(a)
RETURN

Preklad a spustenie#

action26 bits.act --sim

Čo uvidíš#

a           00001100 = 12
b           00001010 = 10
a AND b     00001000 = 8
a OR b      00001110 = 14
a XOR b     00000110 = 6
a LSH 1     00011000 = 24
a RSH 2     00000011 = 3
bit 7 on    10000101 = 133
bit 7 off   00000101 = 5

Ako to funguje#

Porovnaj stĺpce nad sebou:

a        00001100
b        00001010
a AND b  00001000    jednotka len tam, kde ju majú obe
a OR b   00001110    jednotka tam, kde ju má aspoň jedno
a XOR b  00000110    jednotka tam, kde sa líšia

• a LSH 1 posunie všetko o miesto doľava: z 12 je 24, dvojnásobok.
• a RSH 2 posunie o dve miesta doprava: 12 delené 4 je 3. Bity, ktoré „vypadnú“ z kraja, sa stratia.
• a==%128 zapne bit 7 a ostatné nechá: z 5 je 133.
• a==&127 – 127 je 01111111, všetky bity okrem siedmeho. AND s ním bit 7 vypne a ostatné nechá.

Procedúra Bits ukazuje, ako sa bity čítajú: maska začne na 128 (bit 7) a každým krokom sa posunie doprava (mask==RSH 1). value&mask je nenulové práve vtedy, keď je daný bit v value zapnutý – a podmienka bez porovnania platí, keď je výsledok nenulový.

Časté chyby#

Vyskúšaj si#

1. Vypíš v dvojkovej sústave čísla 0 až 15.
2. Napíš BYTE FUNC IsOdd(BYTE n), ktorá zistí nepárnosť bitovou operáciou (nepárne číslo má zapnutý bit 0).
3. Kód malého písmena je o 32 väčší ako kód veľkého – líšia sa bitom 5. Preveď znak 'a na veľké písmeno vypnutím toho bitu.

Zhrnutie#

• Bajt má 8 bitov s hodnotami 1, 2, 4 … 128.
• & (AND) vyberá a vypína bity, % (OR) zapína, ! (XOR) prepína.
• LSH a RSH posúvajú bity – násobia a delia dvoma.
• Test bitu: IF x&maska THEN.

Späť: 21. Záznamy · Ďalej: 23. Program vo viacerých súboroch

23. Program vo viacerých súboroch: INCLUDE a SET#

Na čo to je#

Rutiny, ktoré sa hodia do viacerých programov, nechceš zakaždým kopírovať. Dáš ich do vlastného súboru a program si ho vloží príkazom INCLUDE. Tak vzniká vlastná knižnica.

Druhá polovica kapitoly je o SET – pokyne, ktorým sa v starých programoch nastavuje prekladač.

INCLUDE: ako sa to píše#

INCLUDE "D:MENO.ACT"

Prekladač na tomto mieste prečíta celý súbor MENO.ACT, akoby bol jeho text napísaný priamo tu. Potom pokračuje ďalším riadkom.

• D: je označenie disketovej jednotky na Atari. action26 ho preskočí – zaujíma ho len meno súboru. Píše sa preto, aby program preložil aj pôvodný Action!.
• Súbor sa hľadá v priečinku, kde leží program, ktorý ho vkladá.
• Meno bez prípony dostane .ACT.
• INCLUDE patrí tam, kde by mohol stáť obsah súboru – rutiny knižnice teda vkladaj na začiatok, pred rutiny, ktoré ich volajú.

Celý program#

Knižnica – súbor examples/shapes.act:

; A small library: routines that draw with characters.
; This file is not a program of its own. Other programs INCLUDE it.

PROC ShapeLine(BYTE width, CHAR c)
  BYTE i

  FOR i=1 TO width
  DO
    Put(c)
  OD
  PutE()
RETURN

PROC ShapeBox(BYTE width, height, CHAR c)
  BYTE row

  FOR row=1 TO height
  DO
    ShapeLine(width, c)
  OD
RETURN

Program – súbor examples/include.act:

; A program in two files

INCLUDE "D:SHAPES.ACT"       ; the routines of shapes.act are now known

PROC Main()
  ShapeLine(12, '=)
  ShapeBox(6, 2, '#)
  ShapeLine(12, '=)
RETURN

Preklad a spustenie#

Prekladá sa len hlavný program. Knižnicu si nájde sám:

action26 include.act --sim

Čo uvidíš#

============
######
######
============

Ako to funguje#

Keď prekladač narazí na INCLUDE "D:SHAPES.ACT", otvorí shapes.act, preloží obe procedúry a vráti sa do include.act. Pre Main sú potom ShapeLine a ShapeBox známe, ako keby boli v tom istom súbore nad ňou.

Mená v knižnici začínajú rovnakým slovom (Shape…). Action! nemá oddelené priestory mien – všetky rutiny všetkých vložených súborov sú na jednej hromade. Spoločná predpona bráni tomu, aby sa meno z knižnice zrazilo s menom v programe.

Knižnica v inom priečinku#

Keď knižnice držíš na jednom mieste pre viac programov, povedz prekladaču voľbou -I, kde má hľadať:

action26 include.act -I C:\Atari\lib --sim

Volieb -I môže byť viac. Program sa pritom nemení – v zdrojáku ostáva INCLUDE "D:SHAPES.ACT".

Do pamäte sa dostane len to, čo treba?#

Nie celkom. Rutiny z knižnice jazyka (Print, Graphics …) action26 pribalí len tie, ktoré program volá. Rutiny z tvojho vloženého súboru sa preložia všetky, aj nepoužité. Veľkú knižnicu sa preto oplatí deliť do menších súborov.

SET: nastavenie prekladača#

SET adresa=hodnota

Pôvodný Action! bežal na Atari a jeho nastavenia boli bajty v pamäti. SET počas prekladu zapísal hodnotu na danú adresu a tým prekladač prestavil. action26 týmto zápisom rozumie.

Stretneš najmä túto dvojicu – hovorí, od ktorej adresy má byť program v pamäti:

Súbor examples/set.act:

; SET: this program is placed at address $5000 instead of $2000

SET $E=$5000
SET $491=$5000

PROC Main()
  Print("This routine starts at address ")
  PrintCE(Main)
RETURN

action26 set.act --sim

This routine starts at address 20480

20480 je desiatkovo $5000. Bez dvoch riadkov SET by program začínal na $2000 (8192).

Vo vlastných programoch SET nepotrebuješ. To isté spraví voľba prekladača --org $5000 alebo riadok ;@ORG $5000 na začiatku zdrojáka (kapitoly 32 a 33). Dobré je SET poznať, aby ťa v cudzom programe neprekvapil.

Časté chyby#

Vyskúšaj si#

1. Pridaj do shapes.act procedúru ShapeTriangle(BYTE size, CHAR c) a zavolaj ju z programu.
2. Presuň shapes.act do podpriečinka lib a prelož program s voľbou -I lib.
3. Zmeň v set.act adresu na $3000. Akú adresu program vypíše?

Zhrnutie#

• INCLUDE "D:MENO.ACT" vloží na dané miesto obsah iného súboru.
• Súbor sa hľadá vedľa programu a v priečinkoch z voľby -I.
• Mená v knižnici začínaj spoločnou predponou.
• SET adresa=hodnota nastavuje prekladač; najčastejšie určuje adresu programu. V nových programoch ho nahrádza --org.

Späť: 22. Bity · Ďalej: 24. Pamäť počítača

24. Pamäť počítača: Peek, Poke a premenné na adrese#

Na čo to je#

Atari sa ovláda cez pamäť. Farba pozadia, poloha kurzora, posledný stlačený kláves, stav joysticku – to všetko sú bajty na známych adresách. Kto vie čítať a zapisovať pamäť, vie z počítača dostať všetko, čo knižnica neponúka.

Pamäť Atari v skratke#

Pamäť je rad 65536 bajtov s adresami 0 až 65535 ($0000 až $FFFF). Nie je to jednoliaty priestor:

Zoznam užitočných adries je v prílohe D.

Adresy premenných v RAM ($0000–$05FF) a registrov sú vo všetkých verziách operačného systému rovnaké. Vnútro ROM nie: Atari 800, Atari XL/XE aj voľná náhrada AltirraOS majú na tých istých adresách v ROM iný kód. Do ROM sa preto skáče len cez oficiálne vstupné body – tabuľku od $E450 (napríklad $E456 pre vstup a výstup). Program, ktorý volá rutinu z vnútra ROM na pevnej adrese, beží len s jednou verziou systému.

Ako sa to píše#

Rutiny knižnice#

Peek je anglicky „nakuknúť“, poke „štuchnúť“. Mená pochádzajú z jazyka BASIC.

Premenná na adrese#

BYTE background=710

To je deklarácia z kapitoly 6, pred ktorou si mal byť opatrný: číslo bez hranatých zátvoriek je adresa. Premenná background nedostane vlastné miesto – je bajtom na adrese 710. Zápis background=148 robí to isté ako Poke(710, 148), len sa lepšie číta a je rýchlejší.

Rovnako sa dá položiť na adresu pole:

BYTE ARRAY page6(256)=1536

Celý program#

Súbor examples/memory.act:

; Memory: reading and writing bytes by their address

BYTE background=710          ; this variable IS the byte at address 710
BYTE ARRAY page6(256)=1536   ; an array placed at address 1536 ($600)

PROC Main()
  BYTE value
  CARD word

  Poke(1536, 65)             ; write 65 to address 1536
  value=Peek(1536)           ; read it back
  Print("Address 1536 holds ")
  PrintBE(value)

  PokeC(1538, 50000)         ; a CARD takes two bytes: 1538 and 1539
  word=PeekC(1538)
  Print("Addresses 1538-1539 hold ")
  PrintCE(word)
  Print("Low byte ")   PrintB(Peek(1538))
  Print(", high byte ") PrintBE(Peek(1539))

  page6(4)=7                 ; the same memory through the array
  Print("page6(4) is address 1540: ")
  PrintBE(Peek(1540))
  Print("page6(0) is address 1536: ")
  PrintBE(page6(0))

  background=148             ; the same as Poke(710, 148)
  Print("Address 710 holds ")
  PrintBE(Peek(710))
RETURN

Preklad a spustenie#

action26 memory.act --sim

Čo uvidíš#

Address 1536 holds 65
Addresses 1538-1539 hold 50000
Low byte 80, high byte 195
page6(4) is address 1540: 7
page6(0) is address 1536: 65
Address 710 holds 148

Ako to funguje#

• Poke(1536, 65) a Peek(1536) – zápis a čítanie jedného bajtu. Adresa 1536 je začiatok šiestej stránky, kde programu nič nezavadzia.
• CARD zaberá dva bajty a nižší je prvý. 50000 je 195 × 256 + 80. Na adrese 1538 je 80 (nižší bajt), na 1539 je 195 (vyšší). Toto poradie platí na Atari všade.
• page6 je pole položené na šiestu stránku. page6(4) a adresa 1540 sú to isté miesto. page6(0) ukazuje 65, ktoré tam zapísal Poke na začiatku.
• background=148 zapíše na adresu 710. V simulátore vidíš len číslo; v emulátore sa zmení farba pozadia na modrú, lebo 710 je bunka, z ktorej systém berie farbu pozadia textovej obrazovky.

Skús to v emulátore – pridaj na koniec GetD(7), aby program počkal na kláves (kapitola 2):

action26 memory.act --run

Niekoľko adries na hranie#

Farba je jedno číslo: 16 × odtieň + jas. 148 je odtieň 9 a jas 4.

Časté chyby#

Zápis na zlú adresu počítač nepoškodí – stačí ho vypnúť a zapnúť. V emulátore a simulátore sa nemôže stať vôbec nič zlé, takže skúšaj smelo.

Vyskúšaj si#

1. V emulátore zmeň farbu okraja (adresa 712) a jas písma (709).
2. Vypíš Peek(53770) desaťkrát v slučke – v emulátore dostaneš zakaždým iné číslo.
3. Deklaruj BYTE left=82, nastav left=10 a vypíš niekoľko riadkov textu. Čo sa stane v emulátore?

Zhrnutie#

• Pamäť má adresy 0 až 65535; mnohé majú pevný význam.
• Peek/Poke čítajú a píšu bajt, PeekC/PokeC dvojbajtové číslo.
• BYTE meno=adresa je premenná na danej adrese; BYTE meno=[hodnota] je premenná s počiatočnou hodnotou.
• Dvojbajtové číslo má nižší bajt na nižšej adrese.
• Šiesta stránka ($600–$6FF) je voľná pre programy.
• Koľko pamäte ti ešte ostáva po preklade, povie --memory (kapitola 32).

Späť: 23. Program vo viacerých súboroch · Ďalej: 25. Strojový kód

25. Strojový kód: blok [ … ] a rutina na adrese#

Na čo to je#

Procesor Atari (6502) rozumie len číslam – strojovému kódu. Prekladač mení tvoj program práve na také čísla. Action! dovoľuje vložiť strojový kód do programu aj priamo, a zavolať rutinu, ktorá už niekde v pamäti je (napríklad v operačnom systéme).

Túto kapitolu nemusíš vedieť použiť. Stačí vedieť, čo ten zápis znamená, keď ho stretneš v cudzom programe. Staré programy z časopisov ho používajú často – na miestach, kde záležalo na rýchlosti.

Ako sa to píše#

Blok kódu#

[$EE $00 $06]

Čísla v hranatých zátvorkách prekladač vloží do programu presne tak, ako sú, bajt za bajtom. Nič nekontroluje. Číslo väčšie ako 255 sa vloží ako dva bajty (nižší prvý). V bloku môže stáť aj meno premennej alebo rutiny – vloží sa jej adresa.

Blok môže stáť medzi príkazmi rutiny alebo tvoriť celé jej telo.

Rutina zo strojového kódu#

PROC Bump=*()
[$EE $00 $06 $60]

=* znamená „táto rutina začína práve tu a jej telo si napíšem sám“. Prekladač k nej nepridá nič – ani uloženie parametrov. Kód musí sám skončiť inštrukciou návratu ($60).

Rutina na pevnej adrese#

PROC CIO=$E456(BYTE a, x)

Hovorí: „na adrese $E456 už rutina je, len jej dávam meno“. Žiadne telo nenasleduje. Takto sa volajú rutiny operačného systému. Argumenty sa odovzdajú v registroch procesora: prvý bajt v registri A, druhý v X, tretí v Y.

Celý program#

Súbor examples/machine.act:

; Machine code inside an Action! program

BYTE counter=1536            ; a byte at address $0600

PROC Bump=*()                ; a routine written in machine code
[$EE $00 $06                 ; INC $0600  - add 1 to the byte at $0600
 $60]                        ; RTS        - return

PROC Main()
  counter=5
  Bump()
  Bump()
  Print("After two calls: ")
  PrintBE(counter)

  [$CE $00 $06]              ; DEC $0600  - a code block between statements
  Print("After the code block: ")
  PrintBE(counter)
RETURN

Preklad a spustenie#

action26 machine.act --sim

Čo uvidíš#

After two calls: 7
After the code block: 6

Ako to funguje#

• $EE $00 $06 je inštrukcia procesora INC $0600: pripočítaj 1 k bajtu na adrese $0600. Prvý bajt je kód inštrukcie, ďalšie dva adresa (nižší bajt prvý – ako v kapitole 24).
• $60 je RTS, návrat z rutiny.
• counter je premenná položená na adresu $0600 (1536), takže strojový kód a program v Action! menia ten istý bajt.
• Bump() sa volá ako každá iná procedúra.
• [$CE $00 $06] uprostred Main je DEC $0600 – odčítaj 1. Vykoná sa v poradí medzi okolitými príkazmi.

Komentáre za bajtmi hovoria, aká inštrukcia to je. Bez nich je blok kódu len rad čísel, ktorým nikto nerozumie – ani autor o mesiac neskôr.

Kedy to použiť#

Skoro nikdy. action26 prekladá Action! do rýchleho kódu a to, čo sa kedysi písalo v strojovom kóde, dnes zvyčajne netreba. Výnimky:

• obsluha prerušení (napríklad zmena farby na každom riadku obrazovky),
• volanie rutiny operačného systému, ktorú knižnica nemá,
• prepis starého programu, ktorý bloky kódu už obsahuje.

Ak sa chceš strojovému kódu venovať, action26 má pohodlnejší spôsob než čísla: blok ASM … ENDASM, do ktorého sa píšu inštrukcie menami (inc counter). Je to rozšírenie nad rámec pôvodného Action! a opisuje ho kapitola 37.

Časté chyby#

Prekladač v bloku kódu nekontroluje nič.

Vyskúšaj si#

1. Pridaj tretie volanie Bump() a over výsledok.
2. Zmeň prvý bajt bloku v Main z $CE na $EE. Čo sa vypíše?
3. Prelož program s voľbou --listing machine.lst a otvor vzniknutý súbor v editore. Nájdi v ňom svoje bajty – a pozri, ako prekladač preložil ostatné riadky.

action26 machine.act --listing machine.lst

Zhrnutie#

• [ … ] vloží do programu bajty presne tak, ako sú napísané.
• PROC Meno=*() je rutina, ktorej telo je celé zo strojového kódu.
• PROC Meno=adresa(…) dá meno rutine, ktorá už v pamäti je.
• Prekladač strojový kód nekontroluje; komentuj každú inštrukciu.

Späť: 24. Pamäť počítača · Ďalej: 26. Formátovaný výpis a prevody

26. Formátovaný výpis a prevody: PrintF, Str…, Val…#

Na čo to je#

Veta „Pedro is 12 years old.“ potrebovala doteraz štyri príkazy: Print, Print, PrintB, PrintE. PrintF to zvládne jedným. Druhá polovica kapitoly je o prevode čísla na text a späť.

PrintF: ako sa to píše#

PrintF("text so značkami", hodnota1, hodnota2, …)

Prvý parameter je formát: text, v ktorom sú na miestach hodnôt značky začínajúce znakom %. Ďalšie parametre sú hodnoty, ktoré sa na miesta značiek dosadia – v poradí, v akom idú.

Hodnôt môže byť najviac päť.

Prevody: ako sa to píše#

Str… sú procedúry: výsledok uložia do reťazca, ktorý im dáš. Val… sú funkcie: vrátia číslo.

Celý program#

Súbor examples/printf.act:

; PrintF and the conversions between numbers and strings

PROC Main()
  CHAR ARRAY name="Pedro", text(10)
  BYTE age
  CARD score, number
  INT  change

  age=12
  score=40000
  change=-25

  PrintF("%S is %U years old.%E", name, age)
  PrintF("Score %U, change %I%E", score, change)
  PrintF("%U in hexadecimal is %H%E", score, score)
  PrintF("A character: %C, a percent sign: %%%E", 'A)

  StrC(score, text)          ; a number into a string
  Print("As a string: ")
  PrintE(text)
  Print("It has ")
  PrintB(text(0))
  PrintE(" characters")

  number=ValC("1234")        ; a string into a number
  Print("ValC(""1234"") plus 1 is ")
  PrintCE(number+1)

  change=ValI("-77")
  Print("ValI(""-77"") times 2 is ")
  PrintIE(change*2)
RETURN

Preklad a spustenie#

action26 printf.act --sim

Čo uvidíš#

Pedro is 12 years old.
Score 40000, change -25
40000 in hexadecimal is $9C40
A character: A, a percent sign: %
As a string: 40000
It has 5 characters
ValC("1234") plus 1 is 1235
ValI("-77") times 2 is -154

Ako to funguje#

• V prvom PrintF sú dve značky a dve hodnoty: %S dostane name, %U dostane age. %E na konci ukončí riadok – PrintF to sám nespraví.
• %U a %I sa líšia tým, ako číslo čítajú. −25 vypísané cez %U by bolo 65511.
• %H vypíše to isté číslo šestnástkovo. Hodí sa pri práci s adresami.
• StrC(score, text) uloží do text reťazec "40000". Od tej chvíle je to obyčajný reťazec: má dĺžku 5 v text(0) a dá sa s ním robiť všetko z kapitoly 19.
• ValC("1234") vráti číslo 1234, s ktorým sa dá počítať.

Kedy prevody potrebuješ: keď chceš číslo zarovnať, vložiť do dlhšieho textu, alebo spracovať vstup znak po znaku. InputB() z kapitoly 8 nerobí nič iné ako InputS a potom ValB.

Časté chyby#