Omikron BASIC pro Atari ST

Přehled syntaxe a příkazů interpreteru a kompilátoru Omikron.BASIC se zaměřením na verzi řady 5.x (5.16). Příklady jsou psané tak, aby šly rovnou vložit do editoru.

Co je v příručce ověřeno a co ne

Samotný manuál k verzi 5.16 jsem k dispozici neměl. Jádro jazyka (proměnné, řízení toku, procedury, grafika, soubory, systémová volání) vychází z podrobného popisu verze 3.01. Příkazy, které tam jsou, se v řadě 3.5 až 5.x nezměnily, jen přibyly další. Novinky řady 5.x (editor v okně GEM, RUNKERN, integrovaný kompilátor, knihovny) pocházejí z dobové recenze verze 5.02. Místa, která si u 5.16 zkontroluj v tištěném manuálu nebo v nápovědě, mají štítek ověřit. Novinky z řady 5 jsou označené 5.x.

1. Verze a co přinesla řada 5

Omikron.BASIC vznikl v polovině 80. let (Omikron.Soft + Hardware GmbH, Německo) a je napsaný v assembleru 68000. Interpreter 3.x byl v Německu od roku 1988 přibalován k počítačům ST, kompilátor se kupoval zvlášť. Od roku 1996 vychází řada 5.

Verze	Poznámka
2.x, 3.0x	Interpreter s textovým editorem na celou obrazovku (standardní editor a „super-editor“ s menu). Číslované řádky i návěští.
3.5 (kompilátor), 3.6 (interpreter)	Kompilace do samostatného programu pro TOS, podpora STE a TT. Často označované za nejpohodlnější a nejstabilnější verzi pro skutečný ST.
4.0	Verze pro TT s kódem pro FPU 68881/2, jinak téměř shodná s 3.5/3.6.
5.x	Nově napsaný editor v okně GEM, spouštění přes samostatný RUNKERN, kompilátor zabudovaný v editoru. Navržená pro MagiC a MagiC Mac, běží i pod čistým TOS. Poslední verze pro Atari má číslo kolem 5.20.

Hlavní změny v řadě 5 5.x

Editor je aplikace GEM s okny a dialogy, program lze mít otevřený ve více oknech.
Běh programu zajišťuje samostatná aplikace RUNKERN. Editor mezitím běží na pozadí.
Kompilátor je součástí editoru (menu „Kompilovat“), výpisy hlásí do vlastního okna.
Názvy proměnných, procedur, funkcí a návěští smějí obsahovat podtržítko a znaky ASCII od 128 výš.
Příkazy lze zkracovat tečkou (PR. místo PRINT). Při nejednoznačnosti se vybere příkaz s nejnižším kódem tokenu.
Automatické doplňování jmen proměnných z tabulky proměnných.
Bez postfixu je proměnná standardně dlouhé celé číslo (32 bitů).
Knihovny (.LIB) se ukládají ve formátu LIBRARY CODE přímo do programu. Kompilátor z nich sám odstraní nepoužité procedury.
Programy uložené ve verzi 5.x se zpravidla nedají načíst ve starších verzích. Pro výměnu uložte zdroj do ASCII.

Paměť a systém

RUNKERN pracuje pouze v 24bitovém adresovém prostoru, tedy v ST-RAM. Kód editoru lze umístit do TT-RAM. Pod MagiC se doporučují alespoň 2 MB RAM. Pod jednoúlohovým TOS nejde RUNKERN spustit přímo z editoru. Program uložíte, editor ukončíte a soubor přetáhnete na ikonu RUNKERNu.

2. Prostředí a práce v editoru

Start programu a ladění 5.x

Program z horního okna se uloží jako PROGRAMM.BAS do složky OM-BASIC.TMP. Tam je tedy vždy naposledy spuštěný program.
Po skončení programu se RUNKERN ukončí a vracíte se do editoru.
Při chybě nebo po STOP přejdete do přímého režimu RUNKERNu. Zjistíte hodnoty proměnných (PRINT, DUMP) nebo zadáte příkaz, případně pokračujete pomocí CONT.
Při startu nového programu se ptá na jméno, velikost paměti pro kód, počet řádků a na to, zda použít čísla řádků. Výchozí hodnoty (asi 64 KB, 1024 řádků) většině programů stačí. Čísla řádků lze zapnout i později.
Informační řádek okna ukazuje pozici kurzoru a velikost programu. Klepnutí na údaj „Y=“ otevře dialog Jdi na řádek.
Syntaktická chyba při zadání řádku se označí červeně (na monochromatickém monitoru šedě) a popis chyby se objeví v informačním řádku.
Limity: nejvýše 16 384 proměnných, procedur a funkcí dohromady a nejvýše 65 536 řádků.

Doplňování jmen proměnných 5.x

Napiš začátek názvu a stiskni Ctrl+* (nebo Shift+Tab). Editor dopíše první shodu z tabulky proměnných. Dalším stiskem nebo Ctrl++ listuješ dopředu, Ctrl+− listuje zpět.

Ukládání

Příkaz / volba	Význam
`SAVE "JMENO.BAS"`	Uloží program ve vlastním rychlém formátu (FIT, Fast Interpreting Technic).
`SAVE "JMENO.BAS", A`	Uloží zdroj jako ASCII (znak po znaku).
`LOAD "JMENO.BAS"`	Načte program uložený jako FIT i jako ASCII.
„ASCII uložit“ v menu 5.x	Znaky 10, 13 a 26 jsou řídicí. Pokud je zdroj obsahuje v řetězcích, dělá načtení potíže. Proto existuje přepínač Nový ASCII formát, který tento problém řeší, ale takový soubor nenačte cizí editor.

Standardní editor ve verzi 3.x (pro srovnání)

Verze 3.x má dva editory. První je řádkový s čísly řádků, druhý je „super-editor“ s menu a myší. Příkazy standardního editoru:

`LIST`, `LIST n`, `LIST m-n`	Výpis programu nebo jeho části.
`RENUM`, `RENUM m`, `RENUM l,m,n`	Přečíslování (po 10, od řádku m, nebo l,m,n).
`RUN`, `RUN 100`, `RUN Aum`	Smaže proměnné a spustí od začátku, od řádku nebo od návěští `-Aum`.
`GOTO n`	Spustí od řádku bez mazání proměnných.
`CLEAR`	Vynuluje proměnné, zavře soubory, vypne podmíněné podprogramy.
`NEW`	Smaže program v paměti.
`CLS`	Vymaže obrazovku.
`KEY n = "text"`, `KEY LIST`	Definice funkčních kláves (20 kláves, text až 32 znaků).
`QUIT` / `SYSTEM`	Ukončí interpreter (po potvrzení).
`STOP`, `CONT`, `CONT TO n`, `CONT m TO n`	Přerušení a pokračování. `Ctrl`+`C` zastaví program, `Ctrl`+`S` / `Ctrl`+`Q` pozastaví a obnoví.
`DUMP`, `DUMP V,W`	Vypíše proměnné a jejich hodnoty (případně jen začínající na V, W).
`END`	Ukončí program a zavře soubory.

3. Základní stavba programu

Řádek může mít číslo (10 PRINT "Ahoj"), v řadě 5 se čísla dají vypnout a pracovat jen s návěštími a procedurami.
Víc příkazů na řádku se odděluje dvojtečkou :.
Komentář začíná REM nebo apostrofem ' a platí do konce řádku.
Návěští se píše s pomlčkou na začátku: -Start. Skáče se na něj bez pomlčky: GOTO Start. Návěští je rychlejší než číslo řádku a přežije RENUM.
Klíčová slova se píší velkými písmeny (editor je sám převede). Názvy proměnných nesmí být shodné s příkazem.
Otazník je zkratka příkazu PRINT: ? 3*5.

KOSTRA.BAS

' Kostra programu: hlavní část, na konci END, pod ním procedury
CLS
INPUT "Jak se jmenuješ: "; Jmeno$
Pozdrav(Jmeno$)
PRINT "Součet 3+4 ="; FN Soucet(3, 4)
END

DEF PROC Pozdrav(T$)
  PRINT "Ahoj, "; T$; "!"
RETURN

DEF FN Soucet(A, B) = A + B

Proč definovat procedury až za END

Interpreter by na DEF PROC narazil přímo při běhu a ohlásil chybu „Illegal direct“. Procedury, funkce a podprogramy (GOSUB) proto patří za END.

4. Proměnné a datové typy

Název proměnné tvoří písmena bez diakritiky, číslice a podtržítko, nesmí začínat číslicí. Typ určuje přípona:

Zápis	Typ	Rozsah / velikost
`V%` nebo `V%W`	krátké celé číslo	−32 768 až 32 767 (16 bitů)
`V` nebo `V%L`	dlouhé celé číslo (výchozí)	−2 147 483 648 až 2 147 483 647 (32 bitů)
`V!`	reálné číslo, jednoduchá přesnost	6 bajtů, 9 platných číslic
`V#`	reálné číslo, dvojitá přesnost	10 bajtů, 19 platných číslic
`V$`	řetězec	do 32 767 znaků
`V%F`	logická hodnota (0 nebo −1)	jen v polích
`V%B`	bajt (0 až 255)	jen v polích

Nejčastější past: celé číslo místo reálného

Proměnná bez přípony je celé číslo. V = .1 : PRINT 1/V zaokrouhlí V na 0 a skončí chybou „Division by zero“. Pro necelá čísla používej V! nebo V#, případně deklaruj typ příkazem DEFSNG / DEFDBL.

Deklarace typu podle prvního písmena

`DEFINT "Q"`	proměnné začínající na Q budou krátká celá čísla
`DEFINTL "R"`	dlouhá celá čísla (výchozí)
`DEFSNG "C,L"`	jednoduchá reálná čísla
`DEFDBL "D-H"`	dvojitá přesnost pro D až H
`DEFSTR "A"`	řetězce

Příkazy DEF… patří na úplný začátek programu. Pokud je potřebuješ doplnit později, ulož zdroj jako ASCII a znovu ho načti.

Číselné soustavy

`%1000101` nebo `&B…`	dvojková
`&7532` nebo `&O…`	osmičková
`$2F` nebo `&H…`	šestnáctková
`BIN$(n)`, `OCT$(n)`, `HEX$(n)`	převod čísla na řetězec v dané soustavě
`VAL("$7FFF")`	převod řetězce (i s předponou soustavy) na číslo
`HIGH(n)`, `LOW(n)`	horní a dolní slovo dlouhého čísla

Převody typů

`CINT(x)`, `CINTL(x)`	na krátké / dlouhé celé číslo
`CSNG(x)`, `CDBL(x)`	na reálné jednoduché / dvojité přesnosti
`CVI`, `CVIL`, `CVS`, `CVD`	binární řetězec (2, 4, 6, 10 znaků) na číslo
`MKI$`, `MKIL$`, `MKS$`, `MKD$`	číslo na binární řetězec
`STR$(x)`, `VAL(s$)`	číslo ↔ text
`ASC(s$)`, `CHR$(n)`	kód ↔ znak (CHR$ pro 0 až 255)

5. Operátory a matematické funkce

Aritmetika a porovnání

`+ - * / ^`	základní operace a mocnina (`2^16 = 65536`)
`\`	celočíselné dělení: `43\5 = 8` (rychlejší než `/`)
`MOD`	zbytek: `43 MOD 5 = 3`
`= < > <= >= <>`	porovnání. Výsledek je −1 (pravda) nebo 0 (nepravda): `A = (B = 6)`
`+= -= …`	zkrácené přiřazení: `X += 1` je rychlejší než `X = X + 1`
`LET`	nepovinné, jen pro kompatibilitu
`ABS`, `SGN`	absolutní hodnota, znaménko (−1, 0, 1)
`INT`, `FIX`, `FRAC`	`INT(-4.3) = -5` (dolů), `FIX(4.3) = 4` (odříznutí), `FRAC(4.3) = .3`
`MIN(a,b)`, `MAX(a,b)`	menší / větší ze dvou hodnot (i řetězců podle abecedy)
`SWAP A,B`	výměna obsahu dvou proměnných

Goniometrie a mocniny

`DEG`, `RAD`	úhly ve stupních / v radiánech (výchozí radiány)
`PI`	Ludolfovo číslo ve dvojité přesnosti
`SIN COS TAN COT SEC COSEC`	základní funkce
`ARCSIN ARCCOS ARCTAN (ATN) ARCCOT`	cyklometrické funkce
`SINH COSH TANH COTH SECH COSECH`, `ARSINH ARTANH ARCOTH`	hyperbolické funkce a jejich inverze
`SQR(n)`, `EXP(n)`, `LN(n)`	odmocnina, eⁿ, přirozený logaritmus
`LOG(a, b)`	logaritmus čísla b o základu a: `LOG(2, 8) = 3`
`FACT(n)`	faktoriál

Náhodná čísla

`RND(1)`	reálné číslo od 0 do téměř 1
`RND(n)`	celé číslo 0 až n−1
`-RND(-n)`	celé číslo 1 až n. Kostka: `-RND(-6)`
`RND(0)`	naposledy vygenerované číslo

Pozor: součet dvou kostek -RND(-6) - RND(-6) má jiné rozdělení než jedno -RND(-12).

Bitové a logické operace

`NOT AND OR XOR`	pracují s jednotlivými bity. `%1100 AND %1010` dá `%1000`
`NAND NOR EQV IMP`	další logické spojky
`SHL(n)` / `SHR(n)`	posun bitů doleva / doprava (násobení, dělení dvěma)
`BIT(n, A)`	hodnota bitu n čísla A (0 nebo −1). Bit 0 je nejnižší

6. Řetězce

`A$ + B$`	spojení
`"Ni!" * 3`	opakování (násobitel za řetězcem): `Ni!Ni!Ni!`
`LEN(a$)`	délka
`LEFT$(a$, n)`, `RIGHT$(a$, n)`	první / poslední znaky
`MID$(a$, p)`, `MID$(a$, p, n)`	část řetězce od pozice p
`MID$(a$, p, n) = "x"`	přepsání části řetězce
`INSTR(n, a$, b$)`	pozice b$ v a$ od pozice n (0 = nenalezeno)
`SPACE$(n)`, `SPC(n)`	n mezer
`STRING$(n, "x")`, `STRING$(n, kód)`	n stejných znaků
`UPPER$`, `LOWER$`	velká / malá písmena
`MIRROR$(a$)`	obrácený řetězec
`STR$(n)`	číslo jako text. Kladné číslo může mít vpředu skrytý znak mezery nebo plus, takže `LEN(STR$(123))` je 4

Znaky 0 až 31

Řídicí znaky se vypisují jako CHR$(1) + CHR$(n). Samotné CHR$(n) je řídí (např. CHR$(7) pípne, CHR$(13) je návrat vozíku).

7. Pole a matice

POLE.BAS

DIM T#(11)            ' 12 prvků, T#(0) je první
DIM Plan%B(18, 18)    ' tabulka 19x19 bajtů
Pocet%(3, 4) = 29     ' 4. řádek, 5. sloupec

MAT CLEAR Plan%B(18, 18)   ' vynulování pole
SORT A$(0)                 ' seřazení celého pole řetězců
SORT ASC A$(0)             ' řazení podle ASCII kódů
SORT T(0) TO V(0)          ' V se seřadí podle pořadí T

Bez DIM má pole výchozí rozměr 10 × 10.
Indexy začínají od 0, DIM T(11) proto vytvoří 12 prvků.
Typy %F (logická hodnota) a %B (bajt) lze použít jen u polí.
Rychlostní tip: dvourozměrný prvek A(5,5) je pomalejší než obyčejná proměnná A55.

Matice

Matice jsou dvourozměrná reálná pole.

`MAT A#(l, c) * n`	vynásobí všechny prvky číslem n
`MAT A!(m,n) = B!(m,p) * C!(p,n)`	součin matic (počet sloupců první = počet řádků druhé)
`MAT A#(n,n) = INV B#(n,n)`	inverze čtvercové matice
`MAT A#(n,n) = 1`	jednotková matice
`X! = DET(A!(n,n))`	determinant

8. Řízení toku programu

Podmínky: IF … THEN … ELSE … ENDIF

PODMINKA.BAS

' jednořádková
IF Mys = 1 THEN PRINT "levé tlačítko"

' víceřádková: ENDIF je povinné
IF A < N THEN
  PRINT "Víc..."
ELSE
  PRINT "Míň..."
ENDIF

Víceřádkový tvar končí ENDIF. Povinné je i tehdy, když za THEN následuje dvojtečka.
Podmínky se mohou vnořovat. Řetěz IF a THEN IF b THEN IF c THEN … je rychlejší než jedno IF a AND b AND c.
Samotné IF X THEN je pomalejší než IF X = 1 THEN (tip z diskuse k verzi 3.5).
Chybějící ENDIF uvnitř cyklu se často projeví hláškou „Use EXIT“.

Cykly

CYKLY.BAS

FOR I = 10 TO 0 STEP -2
  PRINT I;
NEXT I

REPEAT
  INPUT "Číslo 1 až 100: "; A
UNTIL A >= 1 AND A <= 100

WHILE MOUSEBUT < 2        ' pravé tlačítko ukončí
  DRAW 320, 200 TO MOUSEX, MOUSEY
WEND

WHILE -1                  ' nekonečný cyklus
  A$ = INKEY$
  IF A$ <> "" THEN EXIT
WEND

`FOR V = n TO m [STEP p] … NEXT [V]`	počítaný cyklus, krok může být záporný i reálný
`REPEAT … UNTIL podmínka`	test na konci (tělo proběhne alespoň jednou). Cyklus končí, když podmínka platí
`WHILE podmínka … WEND`	test na začátku. `WHILE -1` je nekonečný cyklus
`EXIT`	opustí nejbližší cyklus (a nuluje jeho čítač)
`EXIT TO -Nav`	opustí i několik vnořených cyklů a skočí na návěští

Z cyklů se vždy vystupuje přes EXIT nebo EXIT TO. Prosté GOTO nechá čítač cyklu na zásobníku a časem ho zahltí. Vnořené cykly navíc pište tak, aby vnější měl méně průchodů (vnitřní s větším počtem je rychlejší).

Skoky a podprogramy

`GOTO 300`, `GOTO Nav`	skok na řádek nebo návěští `-Nav`
`GOTO 500+n`, `GOTO (V)`	vypočtený skok (číslo nebo návěští v proměnné)
`ON n GOTO a, b, c`	rozcestník podle n
`GOSUB Nav`, `RETURN`	klasický podprogram. Patří za `END`
`ON n GOSUB a, b, c`	rozcestník podprogramů

Podmíněné podprogramy (události)

Příkazy se píší na začátek programu a po splnění události zavolají podprogram.

`ON TIMER n GOSUB Nav`	každých n sekund
`ON MOUSEBUT GOSUB Nav`	po klepnutí tlačítkem myši
`ON HELP GOSUB Nav`	po stisku `Help`
`ON KEY GOSUB Nav`	po stisku libovolné klávesy (znak zůstává v bufferu, v podprogramu ho vyber přes `INKEY$`, jinak se podprogram volá stále dokola)
`ON <událost> GOSUB 0`	vypnutí

9. Procedury a funkce

Procedury a funkce jsou hlavní nástroj pro strukturované programování. Volají se jménem, bez GOSUB a číslování řádků.

PROC.BAS

INPUT "Poloměr a výška: "; R!, H!
Kuzel                          ' volání bez parametrů
PRINT "Objem kuželu:"; V!

X! = 6 : Y! = 3
Podil(X!, Y!)                  ' parametry R se vracejí zpět
PRINT X!, Y!
PRINT FN Kostka                ' funkce
PRINT FN Faktorial(5)
END

DEF PROC Kuzel
  V! = R!^2 * PI * H! / 3
RETURN

DEF PROC Podil(R P!, R Q!)    ' R = předání zpět (Return)
  P! = P! / Q!
  Q! = 1 / P!
RETURN

DEF FN Kostka = -RND(-6) - RND(-6)    ' jednořádková funkce

DEF FN Faktorial(N)
  IF N = 0 THEN RETURN 1
RETURN N * FN Faktorial(N - 1)       ' rekurze

DEF PROC jmeno[(parametry)] … RETURN definuje proceduru. Volání je prosté jmeno(hodnoty). Ve zdrojácích se navíc používá PROC jmeno(…) (volání s klíčovým slovem), obojí je platné.
Parametr označený R se po návratu zapíše zpět do volající proměnné. Ostatní se předávají hodnotou.
Proměnné jsou ve výchozím stavu globální. LOCAL V$=, W$= uvnitř procedury vytvoří lokální proměnné stejných jmen, které globální nepřepíšou.
DEF FN jmeno[(parametry)] vrací právě jednu hodnotu v příkazu RETURN hodnota. Volá se FN jmeno. Funkce vracející řetězec má v názvu $ (FN Obrat$).
Jednořádková funkce DEF FN F(X) = výraz nepotřebuje RETURN.
Jména procedur a funkcí musí být jedinečná, jinak vznikne chyba „Duplicate definition“.
V FN použij k opuštění vnořených cyklů EXIT TO.

Zřetězení programů

CHAIN "JMENO", n načte další program a smaže předchozí, CHAIN MERGE "JMENO", n ho přidá k existujícímu. Proměnné se mezi programy přenášejí příkazem COMMON V$, W$ na prvním řádku každého programu. LOCAL pomáhá, aby se v zřetězených programech nepletly stejně pojmenované proměnné.

10. DATA a READ

DATA.BAS

ON Jazyk RESTORE Cesky, Anglicky   ' výběr bloku podle hodnoty Jazyk
FOR I = 0 TO 2
  READ Slovo$
  PRINT Slovo$
NEXT
END

-Cesky
DATA "Nula", "Jedna", "Dva"
-Anglicky
DATA "Zero", "One", "Two"

`DATA a, b, "c"`	uložení dat (výrazy, proměnné, pole)
`READ V$, W`	čtení dalších hodnot
`RESTORE`, `RESTORE Nav`, `RESTORE 1000`	přesun ukazatele na první DATA, na návěští nebo na řádek
`ON n RESTORE a, b, c`	výběr datového bloku

11. Textový výstup a vstup

PRINT

`PRINT a; b`	bez mezery mezi položkami
`PRINT a, b`	oddělí tabulátorem
`PRINT a;`	středník na konci potlačí odřádkování
`PRINT @(řádek, sloupec); text`	tisk na pevnou pozici (řádky od 0)
`LOCATE ř, s`, `CSRLIN`, `POS(0)`	nastavení a zjištění pozice kurzoru
`TAB(c)`, `SPC(n)`	zarovnání
`WRITE "text"`	vypíše včetně uvozovek
`PRINT CHR$(27)+"f"` / `"e"`	skrytí / zobrazení textového kurzoru
`CLS`	smazání obrazovky

PRINT USING – formátování čísel

`USING "####"`	celé číslo na 4 místa (při přetečení vytiskne %)
`USING "####.##"`	dvě desetinná místa
`USING ",####.###"`	oddělovač tisíců
`USING "+#####"`	zobrazí vždy znaménko
`USING "*$#######.##"`	prázdná místa se vyplní hvězdičkou
`USING "###^^^^"`	exponenciální tvar
`PRINT USING "###.#"; V!`	formát jen pro tento `PRINT`
`USING "##.##"` samostatně	formát pro všechny další `PRINT`, `STR$` a `PRINT #`
`USING` bez argumentu	zrušení

Vstup

VSTUP.BAS

INPUT "Věk: "; Vek
INPUT "Jméno: "; Jmeno$
LINE INPUT A$                  ' celý řádek včetně čárek
INPUT @(5, 10); "Text: "; T$   ' na pevné pozici

' čekání na klávesu
REPEAT
  K$ = INKEY$
UNTIL K$ > ""
Ascii = ASC(RIGHT$(K$, 1))      ' 4. znak = ASCII kód
Scan  = ASC(MID$(K$, 2, 1))     ' 2. znak = scan kód

INKEY$ nečeká. Vrací 4znakový řetězec: 1. znak obsahuje stav Shift/Ctrl/Alt/CapsLock v bitech 0 až 4, 2. znak je scan kód, 4. ASCII kód.
INPUT$(n) čeká na n znaků. Kódy funkčních kláves: F1 až F10 mají scan kódy $3B až $44.
INPUT … USING "povolené znaky", R, N, kód, P omezí vstup: 0 povolí číslice, A písmena, U/L převede na velká/malá, +x povolí znak, -x zakáže, N určuje maximální délku.

Obrazovky

SCREEN 0 je výchozí obrazovka, SCREEN 1 a SCREEN 2 jsou další dvě, kterým se zadává adresa v paměti zarovnaná na násobek 256 bajtů (u TOS před 1.6). Pro zarovnání se vyhrazuje o 256 bajtů víc, než obrazovka potřebuje (proto MEMORY(32256) v příkladu).

SCREEN.BAS

Adr = (MEMORY(32256) AND $FFFF00) + 256   ' zarovnaná adresa
SCREEN 1, Adr
SCREEN 0                                  ' zpět na výchozí

XBIOS(R, 4) vrátí rozlišení (0 nízké, 1 střední, 2 vysoké). XBIOS(, 5, L Log, L Fyz, Rez) nastaví logickou a fyzickou obrazovku a rozlišení (−1 = beze změny). Díky tomu lze kreslit na jednu obrazovku a zobrazovat druhou (dvojité buffering).

12. Disk a soubory

Práce s disky a adresáři

`FILES "A:\*.BAS"`	výpis souborů (masky `*` a `?`)
`COPY "A:\SOUBOR" TO "C:\SLOZKA\"`	kopie
`NAME "STARE" AS "NOVE"`	přejmenování
`KILL "jmeno"`	smazání souboru
`MKDIR "dir"`, `RMDIR "dir"`, `CHDIR "dir"`	vytvoření, smazání (prázdného) a změna adresáře. `CHDIR ".."` o úroveň výš
`BACKUP "jmeno"`	vytvoří záložní kopii `.BAK` předchozí verze
`FRE("C:")`	volné místo na disku

Cesty

Programy ve vývojovém prostředí hledají další soubory podle umístění interpreteru. Uváděj proto úplnou cestu. Po kompilaci tento problém odpadá.

Načítání a ukládání programů a dat

`RUN "JMENO.BAS"`	načte a spustí
`MERGE "JMENO"`	připojí ASCII program
`BSAVE "J"`, `BSAVE "J", Adr, n`	uloží obrazovku nebo n bajtů z adresy
`BLOAD "J"`, `BLOAD "J", Adr`	načte soubor na obrazovku nebo na adresu (typicky obrázek)

Sekvenční soubory

SEKV.BAS

OPEN "O", 1, "DATA.TXT"        ' zápis (přepíše existující!)
PRINT #1, "Prvni", "Druhy"
WRITE #1, "s,carkou", 42
CLOSE 1

OPEN "I", 2, "DATA.TXT"        ' čtení
WHILE NOT EOF(2)
  LINE INPUT #2, R$
  PRINT R$
WEND
CLOSE 2

Režimy: "O" zápis, "I" čtení, "A" připisování. Kanály jsou 1 až 16.
INPUT #k, a$, b$ čte čárkou oddělené položky, LINE INPUT #k, a$ celý řádek, INPUT$(n, k) n znaků.
EOF(k) je −1 na konci souboru, LOF(k) je jeho délka.
Zvláštní kanály: "K" klávesnice, "P" tiskárna, "V" modem, "M" MIDI, "C" konzole.
CMD kanál přesměruje výstup PRINT do otevřeného kanálu (užitečné pro zápis výpisu programu do souboru).

Soubory s pevnými záznamy

REC.BAS

OPEN "R", 1, "OSOBY.DAT", 40          ' záznam 40 bajtů
FIELD 1, 30 AS Jmeno$, 10 AS Telefon$
LSET Jmeno$ = "Novák"                 ' zarovnání doleva
RSET Telefon$ = "123456"              ' doprava
PUT 1, 5                              ' zapíše záznam č. 5
GET 1, 5                              ' přečte záznam č. 5
CLOSE 1

SEEK k, n, režim posune ukazatel (0 od začátku, 1 od aktuální pozice, 2 od konce). LOF(k) vrací u souborů s pevnými záznamy počet záznamů a LOC(k) číslo posledního zpracovaného záznamu. Kanál "U" otevře soubor bez pevné délky záznamu. Kanál "F" čte obsah adresáře.

13. Grafika

Počátek (0,0) je levý horní roh. Rozlišení ST: 640×400 (vysoké), 640×200 (střední), 320×200 (nízké). Před kreslením vypni myš (MOUSEOFF) a omez oblast kreslení pomocí CLIP.

Vždy používej CLIP

Obrazovka je součástí běžné paměti. Výplň (FILL) nebo kreslení mimo obrazovku může přepsat paměť a skončit chybou „Internal error“ a studeným resetem. Příklad pro nízké rozlišení: CLIP 0, 0, 320, 200.

Režimy a okno

`CLIP x,y TO u,v` / `CLIP x,y,š,v`	nastaví kreslicí okno. `CLIP` bez parametrů ho zruší
`MODE = 1` až `4`	1 přepsat (výchozí), 2 průhledný (OR), 3 exkluzivní (XOR), 4 inverzní průhledný
`WVBL`	počká na zpětný běh paprsku (klidnější animace)
`NDC x,y,š,v` / `NDC`	virtuální souřadnice (0 až 32 767, osa Y roste nahoru). `NDC` bez parametrů je vypne

Body, čáry, tvary

TVARY.BAS

CLIP 0, 0, 640, 400 : CLS
MOUSEOFF

DRAW 100, 100                         ' bod
DRAW 200, 50 TO 200, 350 TO 400, 350  ' lomená čára
LINE WIDTH = 3 : LINE STYLE = 3       ' tloušťka, tečkovaně

BOX 50, 50 TO 150, 120                ' dva rohy
BOX 50, 50, 100, 70                   ' roh + šířka, výška
RBOX 200, 200 TO 300, 280             ' zaoblené rohy
CIRCLE 400, 200, 60                   ' kruh
CIRCLE 400, 200, 80, 0, 900           ' oblouk (desetiny stupně)
ELLIPSE 500, 300, 80, 40

FILL STYLE = 2, 13                    ' vzor výplně
PBOX 20, 300, 120, 380                ' vyplněný obdélník
PCIRCLE 300, 330, 40
FILL 60, 340, -1                      ' zaplavení uzavřené plochy

`DRAW x,y` / `DRAW x,y TO u,v [TO …]` / `DRAW TO x,y`	bod, čára, pokračování od posledního bodu
`LINE WIDTH = n`	tloušťka čáry (lichá hodnota do 39)
`LINE STYLE = n`	0 neviditelná, 1 plná, 2 čárkovaná dlouhá, 3 tečkovaná, 4 čerchovaná, 5 přerušovaná, 6 kombinovaná, 7 vlastní (`LINE PATTERN`)
`LINE PATTERN = $6D2F`	vzor čáry – 16 bitů (1 bit = 1 pixel)
`BOX`, `RBOX`, `CIRCLE`, `ELLIPSE`	obrysy (oblouky: úhly v desetinách stupně)
`POLYGON Pole%(0, 2*n+2)`	mnohoúhelník do 63 stran. Pole obsahuje dvojice X,Y a poslední bod opakuje první
`PBOX`, `PRBOX`, `PCIRCLE`, `PELLIPSE`, `PPOLYGON`	vyplněné obdoby
`FILL STYLE = a, b`	výplň: `0,1` bílá, `1,1` černá, `2,1` až `2,24` vzory, `3,1` až `3,12` čárování, `4,1` vlastní nebo logo Atari
`FILL PATTERN = Pole%(0)`	vlastní výplň – 16 krátkých čísel
`FILL x,y,-1`	zaplaví uzavřenou oblast
`OUTLINE OFF` / `ON`	vypne / zapne obrys vyplněných tvarů
`POINT(x, y)`	číslo barvy bodu

Grafický text

`TEXT x, y, a$`	text na pixelové pozici
`TEXT STYLE = n`	1 tučně, 2 šedě, 4 kurzívou, 8 podtrženě, 16 obrysově (součtem se kombinují). 0 = zrušit
`TEXT HEIGHT = n`	výška v pixelech (13 je standardní, 26 dvojnásobná)
`TEXT ROTATION = 900 / 1800 / 2700`	otočení v desetinách stupně (0 = normálně)

BITBLT – přenos bloků

BLIT.BAS

Adr = MEMORY(28)                       ' místo pro malý blok
BITBLT 0, 1, 7, 11 TO Adr              ' uložení výřezu z obrazovky
REPEAT
  BITBLT Adr TO 10+RND(610), 10+RND(365), 10, 11, 7
UNTIL MOUSEBUT = 2

BITBLT x,y,š,v TO u,v kopíruje oblast obrazovky, BITBLT x,y,š,v TO Adr ji uloží do paměti a BITBLT Adr TO x,y,š,v,režim ji vykreslí. Výchozí režim 3 překryje cíl, ostatní jsou logické operace nad zdrojem a cílem (např. 6 = XOR, 7 = OR, 15 = černá). Pro velikost bloku ve vysokém rozlišení platí 6 + ((X-1)\16 + 1) * 2 * Y bajtů.

Sprity

DEF SPRITE n, rozměr, Pozadí definuje sprite 1 až 6 a vyhradí paměť pro uložení překrytého pozadí. SPRITE n, x, y, Obraz, BarvaMasky, BarvaPopředí ho zobrazí a DEF SPRITE n, 0 ho odstraní. Rozměr 1 až 6 vybírá malý/velký sprite pro nízké, střední a vysoké rozlišení.

Barvy

`PALETTE $777, $700, $070, $000`	nastaví barvy palety (trojmístné RGB, každá složka 0 až 7). STE má 16 odstínů (přidáním 8 se získají půltóny)
`LINE COLOR = n`, `FILL COLOR = n`, `TEXT COLOR = n`	barva čáry, výplně a textu
`PRINT CHR$(27);"b";CHR$(n)` / `"c"`	textová barva popředí / pozadí (0 až 15)
`XBIOS(R, 7, c, n)`	čtení a zápis barvy c

Hardwarové hodnoty (ST): 777 bílá, 000 černá, 700 červená, 070 zelená, 007 modrá, 077 azurová, 707 purpurová, 770 žlutá, 555 světle šedá, 222 tmavě šedá. Pořadí VDI barev se od hardwarového liší, pro nízké rozlišení je mapování PALETTE 0,2,3,6,4,7,5,8,9,10,11,14,12,15,13,1.

14. Myš, joystick, dialogy

`MOUSEON` / `MOUSEOFF`	zobrazení / skrytí kurzoru. Počítají se: po třech `MOUSEOFF` jsou nutné čtyři `MOUSEON`
`MOUSEBUT`	0 žádné, 1 levé, 2 pravé, 3 obě
`MOUSEX`, `MOUSEY`	poloha v pixelech
`JOYSTICK(n)`	stav joysticku 0 nebo 1
`FORM_ALERT(Výchozí, "[S][řádek1\|řádek2][Tlačítko1\|Tlačítko2]", R)`	alert box. S = ikona (0 žádná, 1 „!“, 2 „?“, 3 „STOP“), R vrací číslo zvoleného tlačítka
`FILESELECT(Cesta$, Soubor$, R)`	výběr souboru. R = 1 po potvrzení, 0 po zrušení

Před dialogy zapni myš

MOUSEON musí být zapnutý před voláním FORM_ALERT a FILESELECT. Cestu pro FILESELECT předávej v proměnné, ne jako literál, protože se při volání mění.

DIALOG.BAS

MOUSEON
FORM_ALERT(1, "[2][Opravdu skončit?][Ano|Ne]", Odp)
IF Odp = 1 THEN END

Cesta$ = "A:\*.BAS"
FILESELECT(Cesta$, Soubor$, R)
IF R = 1 THEN PRINT "Vybráno: "; Soubor$

Pro plnohodnotné okenní aplikace s menu a dialogy z resource souboru (.RSC) slouží GEM knihovna a EasyGEM, viz kapitola o knihovnách.

15. Zvuk (Yamaha YM2149)

Čip má tři tónové kanály, generátor obálky a šum.

`PRINT CHR$(7)`	pípnutí
`TUNE 1, n, 2, m, 3, p`	výška tónu kanálů (1 až 4095, vyšší číslo = hlubší tón). Pro 440 Hz platí 125000/440 ≈ 284
`TUNE 1,0, 2,0, 3,0`	ticho
`VOLUME kanál, hlasitost`	hlasitost 0 až 15
`VOLUME v, e, d`	obálka e (tvar) a doba d. Hodnota d = 7860 odpovídá zhruba sekundě
`NOISE maska, filtr`	šum: maska kanálů (1, 2, 4 se sčítají), `NOISE 0,0` vypne

MIDI se ovládá přes kanál OPEN "M", k a funkci XBIOS(R, 12, n, L Adr) pro odeslání bloku bajtů.

16. Paměť, systém a čas

Paměť

`CLEAR m`, `CLEAR m, n`	vyhradí m bajtů pro `MEMORY` (výchozí 64 KB) a volitelně n bajtů pro zásobník
`Adr = MEMORY(n)`	vyhradí n bajtů a vrátí adresu
`Adr = MEMORY("text")`	uloží řetězec a vrátí jeho adresu (pro volání TOS přidej `CHR$(0)`)
`FRE(Adr)`	uvolní blok
`FRE(0)`	volná paměť
`FRE("")`	úklid řetězců (garbage collection) a návrat volné paměti
`PEEK`, `WPEEK`, `LPEEK`	čtení bajtu, slova, dlouhého slova
`POKE`, `WPOKE`, `LPOKE`	zápis bajtu, slova, dlouhého slova
`MEMORY_MOVE n, Zdroj TO Cíl`	kopie bloku (sudé adresy). `MEMORY_MOVEB` zvládá i liché
`MEMORY_BLOCK xx, n, Adr`	pevný blok uložený spolu s programem
`VARPTR(V)`, `SEGPTR`	adresa proměnné a ukazatel na tabulku segmentů interpreteru

BIOS, XBIOS, GEMDOS

Volání systému má tvar XBIOS(R, funkce, parametry…). První parametr R je návratová hodnota (čárku nechej, i když ji nepotřebuješ). Adresu předáváš s předponou L (L Adr), interpreter ji sám rozdělí na dvě slova.

SYSTEM.BAS

XBIOS(Rez, 4)                 ' Rez = 0 nízké, 1 střední, 2 vysoké
GEMDOS(Ver, 48)               ' verze GEMDOSu (Ver \ 256)
GEMDOS(Disk, 25)              ' aktuální disk (0 = A:)
XBIOS(Nahoda, 17)             ' 24bitové pseudonáhodné číslo

Strojový kód

`INLINE "A009"`	vloží do programu strojové instrukce (zápis v hexa)
`DEF USR = Adr`, `Vysl = USR(Hodn)`	volání rutiny. Hodnota je v registru D0 a rutina končí `RTS`
`CALL Adr(L p1, p2…)`	volání rutiny s parametry na zásobníku (od 4(A7))

Interpreter běží v supervizorovém režimu a rutina nesmí do supervizorového režimu přecházet sama.

Čas

`TIME$`, `TIME$ = "15:58:12"`	čtení / nastavení času
`DATE$`	datum. Formát určuje `MODE "USA"`, `MODE "GB"`, `MODE "D"`
`TIMER`	počet 1/200 sekundy od zapnutí
`WAIT n`	čeká n sekund

Přerušení

IPL 3 je normální úroveň. IPL 3 + (1 SHL 31) vypne Ctrl+C. Vyšší úrovně zrychlí program, ale vypnou klávesnici a časovač, takže po dokončení kritické části vrať IPL 3.

17. Chyby a ladění

CHYBY.BAS

ON ERROR GOTO Chyba
OPEN "I", 1, "NENI.TXT"
PRINT "Tohle se nevypíše"
END

-Chyba
PRINT "Chyba"; ERR; ": "; ERR$; " na řádku"; ERL
RESUME NEXT          ' pokračuje další instrukcí

`ERR`, `ERR$`, `ERL`	číslo, text a řádek poslední chyby
`ON ERROR GOTO Nav`	vlastní obsluha chyb
`RESUME`, `RESUME NEXT`, `RESUME Nav`	pokračování: opakuje příkaz / jde dál / skáče na návěští
`ERROR n`	vyvolá chybu n (test obsluhy)
`TRON` / `TROFF`	sledování provádění příkazů (zapíná se a vypíná)
`ON TRON GOSUB Nav`	při zapnutém sledování volá podprogram před každou instrukcí
`STOP`, `CONT`, `DUMP`	zastavení, pokračování, výpis proměnných
`LIST ERL`	vypíše řádek s chybou

Nejčastější chybová hlášení

Hlášení	Příčina
Syntax error	chyba v zápisu příkazu
Illegal direct	procedura nebo funkce se dostala do běhu bez volání. Definuj je až za `END`
Use EXIT	obvykle chybí `ENDIF` uvnitř cyklu
REPEAT without UNTIL / FOR without NEXT / WHILE without END	nesouhlasí ukončení cyklu (obdobně opačné hlášení)
IF without THEN or EXIT	chybí `THEN` nebo `ENDIF`
THEN, ELSE or ENDIF without IF	špatně vnořené podmínky
Type mismatch	smíchané řetězce a čísla
Overflow	číslo mimo rozsah typu
Division by zero	dělení nulou, často kvůli celočíselné proměnné (viz kapitola Proměnné)
Subscript out of range	index mimo pole
Out of memory	málo paměti. Zvětši `CLEAR`, zvlášť pro grafiku a BITBLT
Duplicate definition	dvě procedury / funkce se stejným jménem
Undefined statement	`GOTO` / `GOSUB` na neexistující cíl
RETURN without GOSUB	podprogram je před `END`
Bus error / Address error	`POKE` do zakázané oblasti, slovo na liché adrese
File not found / Path not found / Bad file number	soubor, cesta nebo číslo kanálu (jen 16 kanálů)
Disk full / Disk-write protected / Write error	problém s médiem

Bezpečnostní zásady z praxe

Rezervuj dost paměti (CLEAR n) pro SCREEN, BITBLT, SPRITE a GEMDOS.
Nedávej MOUSEON, TRON ani OUTLINE ON do cyklu bez protějšku, zahltil by se zásobník.
Z cyklů vystupuj přes EXIT / EXIT TO, ne přes GOTO.
Používej CLIP, aby FILL nepřepsal paměť.
RUN, CLEAR a NEW nuluje proměnné a zruší DEG, ale nemění nastavení STYLE, COLOR, TEXT, LINE, MODE, CLIP, TRON, MOUSEON ani USING.
Před uložením na disketu zkontroluj, že není chráněná proti zápisu. Super-editor 3.01 se v takovém případě zasekl.

18. Knihovny a kompilátor

Knihovny 5.x

Knihovny (.LIB) rozšiřují jazyk o procedury a funkce, například GEM.LIB a EasyGEM pro okna, menu a dialogy s resource soubory. Příkazy LIBRARY patří na začátek programu.

LIBRARY.BAS

LIBRARY Gem, "C:\OMIKRON5\GEM.LIB"

Při prvním spuštění se knihovna načte a uloží do posledního řádku programu (65534) jako LIBRARY CODE. Smazáním tohoto řádku knihovnu odstraníš.
Knihovna se ukládá spolu s programem. Nepoužité proměnné se při uložení vyřadí, takže ukládání není výrazně pomalejší.
Knihovní funkce, které volají zpětně kus tvého programu (např. překreslení okna v EasyGEM), nesmí v těchto rutinách provádět DIM, OPEN ani CLOSE, pokud jim byla předána pole.
Programy s GEM knihovnami musí podle licence uvádět použití knihoven Omikron v informačním dialogu.

Kompilace

5.x V editoru zvol Kompilovat pro horní okno. Výpis chyb a nepoužitých příkazů se objeví ve vlastním okně, klepnutím na řádek skočíš do zdroje. Kompilace se kdykoli zastaví klávesou Esc.
Kompilovaný program může být až zhruba desetkrát rychlejší než interpreter. Pro maximální rychlost vypni v možnostech kompilátoru TRACE, čísla řádků a obsluhu výjimek.
Nepotřebné procedury z knihoven kompilátor sám vyřadí.
Chceš-li program předat dál, zkompiluj ho, ochraň proti výpisu (utilita PROTECT.BAS) a odstraň knihovnu ze zdroje.

Řídicí slova kompilátoru ověřit

Z diskusí k verzi 3.5 (v 5.16 ověř v manuálu přesný název a rozsah):

`COMPILER "NOEX"`	nezahrne obsluhu výjimek (při pádu bomby místo hlášení o chybě)
`COMPILER "FPU"`	kód pro koprocesor (u ST s FPU na sběrnici). Pro přenos na Mac se nesmí použít
`COMPILER "BAS_MEM x"`, `COMPILER "STACK x"`	velikost paměti BASICu a zásobníku
`COMPILER "TRON"` / `"TROFF"`	zapíná / vypíná sledovací kód (vypnutý je rychlejší)
`COMPILER ON` / `OFF`	úsek programu, který se nekompiluje
`COMPILER "MMF"` / `"MMB"`	směr kopírování `MEMORY_MOVE` / `MEMORY_MOVEB`

19. Tipy na rychlost

Souhrn z komunitních tipů pro Omikron BASIC. Vyplatí se hlavně v těsných cyklech a v interpretru.

Pomalejší	Rychlejší
`GOTO 123`	`GOTO Nav` (návěští)
`IF X THEN Y = 3`	`IF X = 1 THEN Y = 3`
`DRAW a,b TO c,d : DRAW c,d TO e,f`	`DRAW a,b TO c,d TO e,f`
`IF X=1 AND Y=2 AND Z=3 THEN …`	`IF X=1 THEN IF Y=2 THEN IF Z=3 THEN …`
vnější cyklus s více průchody	vnější cyklus s méně průchody, vnitřní s více
`X = X + 1 : Y = Y - 1`	`X += 1 : Y -= 1`
`A(5,5)` (pole)	`A55` (obyčejná proměnná)
`A = 100 / 2` (reálné dělení)	`A = 100 \ 2` (celočíselné)
reálné proměnné tam, kde stačí celá čísla	celočíselné proměnné (výchozí typ)
konstantní výraz opakovaně v cyklu	výpočet před cyklem do proměnné
`IF A > B THEN B = A` (pro výměnu)	`IF A > B THEN SWAP A, B`

20. Rychlý tahák

Chci…	Použij
Komentář	`REM text` nebo `' text`
Návěští a skok	`-Start` … `GOTO Start`
Proměnná: celá / reálná / řetězec	`A` (nebo `A%` krátké) / `A!`, `A#` / `A$`
Podmínka	`IF … THEN … ELSE … ENDIF`
Cykly	`FOR/NEXT`, `WHILE/WEND`, `REPEAT/UNTIL`
Vyskočit z cyklu	`EXIT`, `EXIT TO -Nav`
Procedura / funkce	`DEF PROC` … `RETURN` / `DEF FN` … `RETURN hodnota`
Lokální proměnné	`LOCAL V$=, W=`
Časovač, klávesa, myš (události)	`ON TIMER`, `ON KEY`, `ON MOUSEBUT` … `GOSUB`
Nulovat obrazovku a kurzor	`CLS`, `LOCATE ř,s`, `PRINT @(ř,s)`
Zadat číslo / text / klávesu	`INPUT`, `LINE INPUT`, `INKEY$`
Dialog Ano/Ne	`FORM_ALERT(1,"[2][Text][Ano\|Ne]",R)`
Soubor číst / psát	`OPEN "I"/"O"/"A"`, `INPUT #`, `PRINT #`, `CLOSE`
Náhoda 1 až n	`-RND(-n)`
Zachytit chybu	`ON ERROR GOTO Nav` + `RESUME`
Přímý přístup k systému	`XBIOS`, `BIOS`, `GEMDOS`, `PEEK/POKE`
Zkompilovat	menu Kompilovat 5.x

Zdroje a doporučená čtení

Podrobný popis Omikron BASICu 3.01 (anglicky/francouzsky), základ jádra příručky: jchr.be/atari/omikron.html
Recenze Omikron-Basic 5.02 v časopise ST-Computer 11/1996 (novinky řady 5): stcarchiv.de
Tipy na rychlost a diskuse o kompilátoru: Atari-Forum, vlákna „Omikron.Basic tips“ a „The end of Omikron.Basic“.
Skeny původních manuálů (německy) jsou na Internet Archive ve sbírce „Ultimate Atari-ST Computer Document Collection“.

U jakéhokoli příkazu, který se chová jinak, než je tu popsáno, platí nápověda a manuál přímo ve tvé verzi 5.16. Pokud mi pošleš konkrétní příkaz nebo chybu, můžu příručku doplnit.