PEBASIC — manuál jazyka

Obsah: 0 Prostředí • 1 Úvod • 2 Struktura programu • 3 Datové typy • 4 Pole • 5 Výrazy a operátory • 6 Příkazy • 7 Funkce • 8 Soubory • 9 SYS • 10 Přímý režim • 11 Chyby • 12 Limity a rozdíly

0. Prostředí (editor a fullscreen)

Levý panel = editor, pravý panel = výstup programu (bez příkazového režimu). F5 (▶ RUN) spustí program z editoru; Ctrl+C / ■ STOP ho přeruší.
⛶ Spustit v novém okně otevře běh bez editoru v samostatné záložce (run.html) — opakovaně se používá ta samá, program se spouští znovu od začátku. Prázdný editor = fullscreen startuje rovnou v přímém režimu.
← Editor ve fullscreen předá aktuální program zpět do editoru (včetně úprav z přímého režimu) a přepne na stejnou editorovou záložku. Pro pouhé nahlédnutí bez restartu stačí přepnout záložku prohlížeče.
LIST vypíše program tak, jak se skutečně spustí (setříděný, bez přepsaných řádků). NEW smaže program, 🧹 Uklidit odstraní přepsané duplicity a seřadí řádky. Duplicitní čísla editor hlásí zaživa (⚠ duplicity), RUN je vypíše před startem — platí vždy poslední zadání.
2. řádek hlavičky = soubory: Soubory (výběr), Stáhnout, Smazat, FILES, Export vše, 📥 Import vše, 📂 Program (soubor .bas do editoru), 💾 Data (datové soubory do paměti prohlížeče).
Při INPUT skočí kurzor sám do vstupního pole (i po návratu na záložku); kliknutí kamkoliv do výstupu ho vrátí.

1. Úvod

PEBASIC je textový interpret jazyka BASIC v dialektu Chipmunk Basic (s kompatibilitou pro běžné GW-BASIC programy), napsaný v JavaScriptu. Při kolizi syntaxe má přednost Chipmunk. Běží v prohlížeči, bez grafiky, multimédií a hardwarově závislých věcí. Na velikosti písmen v příkazech nezáleží.

10 REM hádání čísla
20 RANDOMIZE TIMER
30 X = INT(RND(100)) + 1
40 INPUT "Tip"; T
50 IF T < X THEN PRINT "Větší" : GOTO 40
60 IF T > X THEN PRINT "Menší" : GOTO 40
70 PRINT "Uhodl jsi! Bylo to"; X
80 END

2. Struktura programu

Program tvoří číslované řádky. Provádějí se vzestupně podle čísel, ne podle pořadí v souboru.
Číslo řádku: libovolné kladné celé číslo. Doporučený krok je 10, aby šlo řádky vkládat mezi existující. Duplicitní číslo = přepsání původního řádku (platí poslední zadání). Editor duplicity hlásí (⚠), LIST ukazuje program po přepsání, 🧹 Uklidit ho takto srovná.
Na jednom řádku může být více příkazů oddělených dvojtečkou ::
110 IF hotovo = 1 THEN GOSUB 800 : GOSUB 600 : hotovo = 0
Dvojtečka uvnitř řetězce ("a:b") a v komentáři REM se jako oddělovač nebere.
Komentář: REM text, ' text nebo ` text — ignoruje se zbytek řádku včetně dvojteteček. REM může být i cílem GOTO/GOSUB.
Prázdné řádky se ignorují.

3. Datové typy

3.1 Čísla (bez přípony, `#`, `!`, `&`)

Uložena jako 64bitové desetinné číslo (IEEE-754 double): rozsah cca ±1,8×10³⁰⁸, přesnost asi 15–17 platných cifer.
Literály: 12, -7, 3.14, -.5, 1E3 (= 1000), 2.5E-2. Přípona typu za číslem (5!, 5#, 5%) se ignoruje.
Výchozí hodnota nepřiřazené proměnné: 0.
Je-li výsledkem výpočtu NaN (např. SQR(-1)), uloží se do proměnné 0; přímý PRINT SQR(-1) vypíše NaN.
Přípony # ! & se přijímají, ale chovají se stejně jako číslo bez přípony.

3.2 Celá čísla (`%`)

Zápis: jméno končící %, např. pocet%.
Uložení: ořez na celé číslo a maska na 16 bitů bez znaménka → rozsah 0–65535 (záporné hodnoty se „přetočí": -1 → 65535).
Výchozí hodnota: 0. Vhodné jako čítače a přepínače.

3.3 Řetězce (`$`)

Zápis: jméno končící $, např. jmeno$. Literál v uvozovkách: "Ahoj, světe".
Maximální délka není omezena (jen pamětí prohlížeče).
Výchozí hodnota: prázdný řetězec "".
Přiřazením čísla do $ proměnné se číslo převede na text.
Prázdný řetězec v podmínce IF = nepravda, neprázdný = pravda.

3.4 Jména proměnných

Začínají písmenem, následují písmena, číslice a podtržítka: A, pocet, f_hledano, cas_max2.
Na velikosti nezáleží (Pocet = POCET).
Délka jména není omezena. Typ určuje přípona $ % # ! & (bez přípony = číslo).
Jména začínající FN jsou rezervována pro DEF FN funkce.
Konstanty: PI = 3,141592653589793, TRUE = 1, FALSE = 0.

3.5 Přiřazení

[LET] proměnná = výraz | pole(index…) = výraz | MID$(v$, od [, délka]) = výraz | FIELD$(v$, n [, oddělovač]) = výraz

LET je nepovinné. Pravá strana se vždy vyhodnotí a převede na typ cíle.

LET a = 5
b$ = "x" + "y"
pocet% = 3.9      : REM uloží 3
t(2) = a * 10
MID$(veta$, 7, 5) = "světe"   : REM přepíše podřetězec na místě
FIELD$(radek$, 2) = "Q"       : REM nahradí 2. pole

MID$(v$, od, délka) = text: nahradí v řetězci znaky od pozice od (číslováno od 1) v délce délka (bez délky = délka vkládaného textu). Cíl musí být $ proměnná.
FIELD$(v$, n, oddělovač) = text: nahradí n-té pole (oddělovač výchozí mezera). Mimo rozsah se nic nestane.

4. Pole

DIM jméno(rozměr [, rozměr…]) [, …] | ERASE jméno [, …]

40 DIM jmena$(100), ceny(50, 4)
50 jmena$(1) = "Alena"
60 ceny(2, 3) = 199.5
70 PRINT jmena$(1); ceny(2, 3)
80 ERASE ceny          : REM zruší pole

Indexy se číslují od 0. Kontrola mezí se neprovádí (řídké uložení — paměť zabírají jen použité prvky).
Indexy se zaokrouhlují dolů na celé číslo.
Nedeklarované pole se automaticky vytvoří při prvním použití.
Prvek bez hodnoty: 0 u číselných, "" u $ polí.
ERASE pole zruší (uvolní paměť). Cílem READ mohou být i prvky pole.
Počet rozměrů zjistí ISARRAY(pole), maximum indexu UBOUND(pole [, rozměr]).

5. Výrazy a operátory

5.1 Aritmetika

Operátor	Význam	Příklad → výsledek
`+ - * /`	sčítání, odčítání, násobení, dělení	`7 / 2` → 3.5
`\`	celočíselné dělení (ořez k nule)	`7 \ 2` → 3, `-7 \ 2` → -3
`MOD`	zbytek po dělení (znaménko dělence)	`7 MOD 3` → 1
`^`	mocnina (pravostranně asociativní)	`2 ^ 3 ^ 2` → 512
unární `+ -`	znaménko	`- -5` → 5

Dělení nulou vyhodí chybu: 1/0, 1\0 i 1 MOD 0 → ?Division by zero. Výraz musí být platný celý: zbytek za výrazem (PRINT 1 2, PRINT A1 print a), chybějící operand (X = 5 +) i neznámý znak → ?Syntax error.

5.2 Porovnání

Operátor	Význam
`=`	rovná se
`<>` (i `><`)	nerovná se
`< > <= >=` (i `=<` `=>`)	menší / větší / …

Výsledek: pravda = 1, nepravda = 0 (po chipmunkovsku).
Je-li jeden operand řetězec, porovnává se textově (lexikograficky): "abc" < "b" → 1.
V IF platí: číslo ≠ 0 = pravda, neprázdný řetězec = pravda.

5.3 Logické a bitové operátory

AND OR XOR = bitové operace na 32bitových celých číslech (s hodnotami 1/0 fungují i jako logické).
NOT x = logická negace (0 → 1, cokoli nenulového / neprázdného → 0).

5.4 Priorita (od nejvyšší)

závorky → funkce → ^ → unární minus → * / \ MOD → + - (a spojování řetězců) → porovnání → NOT → AND → OR XOR.

6. Příkazy

CALL / SUB / END SUB / STATIC

SUB jméno [(parametr [, …])] … [STATIC proměnná [, …]] … (RETURN | END SUB)
CALL jméno [(argument [, …])] | jméno(argument [, …])

10 CALL pozdrav("Petr")
20 CALL soucet(3, 4) : PRINT vysledek
30 END
1000 SUB pozdrav(jmeno$)
1010   PRINT "Ahoj " + jmeno$
1020 END SUB
1030 SUB soucet(a, b)
1040   vysledek = a + b
1050 END SUB

Definice SUB…END SUB se při normálním běhu přeskakují (nesmí se do nich spadnout). Vnořování definic není povoleno.
Parametry jsou lokální a předávají se hodnotou; pole se předává odkazem (musí být předem dimenzované).
STATIC deklaruje proměnnou trvalou mezi voláními (počítadla). Ostatní proměnné v SUB jsou globální.
Návratová hodnota: přiřazení do jména subrutiny (soucet = …); po CALL je k dispozici i v stejnojmenné globální proměnné. Rekurze je povolena.
Volání jménem bez CALL (pozdrav("x")) funguje jako příkaz.

CLOSE

CLOSE [#číslo [, …]]

Zavře soubory a zapíše rozpracovaný obsah (režimy O/A) do paměti. Bez parametrů zavře vše. Neexistující číslo → ?File not open.

CLS / HOME

CLS | HOME

Smaže obrazovku terminálu, kurzor do levého horního rohu.

DATA / READ / RESTORE

DATA položka [, …]
READ proměnná [, …]
RESTORE [číslo_řádku]

10 DATA 1, 2, "tři"
20 READ a, b, c$
30 RESTORE
40 RESTORE 10

READ čte postupně hodnoty z DATA v pořadí řádků programu. Čtení za koncem → ?Out of DATA.
Číselný literál bez uvozovek se uloží jako číslo, text v uvozovkách jako řetězec. Položky se oddělují čárkou (i v uvozovkách s čárkou uvnitř).
RESTORE vrátí čtečku na začátek; s číslem řádku na první DATA od tohoto řádku dál.
Cílem READ mohou být proměnné i prvky pole.

DEF FN

DEF FNjméno(parametr [, …]) = výraz

10 DEF FNdvoj(x) = x * 2
20 DEF FNobsah(r) = PI * r ^ 2
30 PRINT FNdvoj(21), FNobsah(1)

Jednořádková uživatelská funkce (jeden výraz, bez příkazů). Jméno vždy začíná FN.
Parametry stíní stejně pojmenované globální proměnné jen po dobu vyhodnocení.
Pro vícepříkazové rutiny použijte SUB.

DIM / ERASE

DIM jméno(rozměr [, …]) [, …] | ERASE jméno [, …]

Viz kapitola 4. Příklad: DIM m(3, 3), seznam$(200).

ELSE / ENDIF (blokový IF)

Součást blokového IF, viz níže.

END / STOP / SYSTEM, EXIT()

END | STOP | SYSTEM | EXIT(výraz)

Ukončí program (STOP stejně jako END). V okně běhu poté následuje přímý režim.

ERASE — viz DIM. EXEC

EXEC(řetězec)

10 prikaz$ = "PRINT " + "x"
20 x = 7
30 EXEC("PRINT x * 2")   : REM vypíše 14

Provede řetězec jako příkaz(y) se sdílenými proměnnými, poli i soubory.

EXIT

EXIT FOR | EXIT WHILE | EXIT

Předčasně opustí cyklus (skočí za NEXT/WEND). Holé EXIT ukončí celý program (používá se např. ve CASE).

FILES / KILL / NAME

FILES
KILL "jméno"
NAME "staré" AS "nové"

FILES vypíše soubory v paměti (prázdné → No files). KILL smaže, NAME přejmenuje (neexistující → ?File not found). Jména se ukládají velkými písmeny.

FOR / NEXT

FOR v = start TO konec [STEP krok] … NEXT [v]

FOR i = 1 TO 10 STEP 2 : PRINT i : NEXT i
FOR i = 10 TO 1 STEP -1 : PRINT i : NEXT

Výchozí krok je 1; krok může být desetinný i záporný. Meze se vyhodnotí jednou na začátku.
POZOR: tělo cyklu proběhne vždy aspoň jednou (počáteční mez se netestuje); o dalším opakování rozhoduje až NEXT (s tolerancí pro desetinná čísla).
NEXT bez proměnné patří k nejvnitřnějšímu cyklu; s proměnnou k danému. NEXT bez FOR → ?NEXT without FOR.
Cykly lze vnořovat. Řídicí proměnná může být i % (pak vyžaduje proměnnou v NEXT).

GET, FPUTBYTE, FSEEK, INPUT$

GET proměnná$
FPUTBYTE hodnota, #číslo
FSEEK #číslo, pozice
INPUT$(počet [, #číslo]) — funkce

GET a$: načte řádek a uloží jeho první znak (v prohlížeči je třeba potvrdit Enterem).
FPUTBYTE: připíše jeden bajt (0–255) do souboru otevřeného pro zápis.
FSEEK: nastaví znakovou pozici pro INPUT$/FGETBYTE (0 = začátek).
INPUT$(n, #f): přečte n znaků ze souboru; bez čísla souboru vrací "" (z konzole čtěte přes INPUT/GET).
GET # / PUT # (náhodný přístup) a OPEN FOR RANDOM nejsou podporovány → chyba.

GOSUB / RETURN, GOTO

GOSUB číslo_řádku … RETURN
GOTO číslo_řádku

Podprogram s návratem na příkaz za GOSUB; hloubka vnoření je omezena jen pamětí. Neexistující řádek → ?Undefined line number. RETURN bez GOSUB → ?RETURN without GOSUB. Uvnitř SUB se RETURN vrací ze subrutiny, pokud není rozpracovaný GOSUB.

IF (jednořádkový)

IF podmínka THEN příkazy [ : … ] [ELSE příkazy] | IF … THEN číslo_řádku

IF a = 5 THEN PRINT "ano" ELSE PRINT "ne"
IF hotovo = 1 THEN f = 0 : GOTO 10
IF x > 9 THEN 200

Celý zbytek řádku za THEN patří větvi THEN — při nesplněné podmínce se přeskočí.
Samotné číslo za THEN znamená skok (GOTO).
Závorky kolem podmínky jsou povoleny: IF (a > 1) THEN PRINT "x".

IF (blokový)

IF podmínka THEN
příkazy…
[ELSE
příkazy…]
ENDIF (i END IF, i IF (podmínka) bez THEN)

IF LEN(volba$) = 1 THEN
  IF volba$ = "x" THEN END
  IF volba$ = "r" THEN GOSUB 500 : GOTO 100
ELSE
  dotaz$ = volba$
ENDIF

Blokové IF poznáte tak, že za THEN nic není (nebo chybí THEN u závorkové podmínky). Bloky lze vnořovat.

INPUT / LINE INPUT

INPUT ["text";] proměnná [, …]
LINE INPUT ["text";] proměnná$

INPUT "Jméno"; j$
INPUT "A,B"; a, b
LINE INPUT "Celý řádek: "; r$

Výzva: text v uvozovkách + ;, jinak se ptá ? (i úvodní INPUT ;). Místo prostého textu může být libovolný řetězcový výraz, např. LINE INPUT "Hrac [" + jmeno$ + "]? "; tah$.
Jedna proměnná čte jeden řádek; více proměnných čeká hodnoty oddělené čárkou (chybějící se doptají dalším ? ).
Vstup do $ proměnné je vždy celý řádek (jako LINE INPUT); počet číselných hodnot nesmí překročit počet číselných proměnných.
Nečíselný vstup do číselné proměnné → Redo from start a opakování dotazu.

LET (přiřazení) — viz 3.5. MAT

10 DIM A(3,3), B(3,3), C(3,3)
20 MAT A = 1          : REM všechno = 1
30 MAT B = IDN        : REM jednotková
40 MAT C = A + B      : REM součet (rozměry musí sedět)
50 MAT C = A * B      : REM součin (vnitřní rozměry musí sedět)
60 MAT C = (2) * A    : REM násobení skalárem
70 MAT B = TRN A      : REM transpozice
80 MAT B = INV A ELSE 200 : REM inverze, singulární → skok
90 MAT PRINT C
100 MAT PRINT USING "###.##"; C

Jen 1D/2D číselná pole; pole musí být předem dimenzované (DIM), jinak ?Array not dimensioned. Neshodné rozměry → ?Matrix dimensions mismatch, singulární matice → ?Singular matrix (nebo ELSE skok).
MAT PRINT tiskne řádky (prvky tabelátorem, s ; mezerou), do souboru s #n. Dolní mez indexů = MAT ORIGIN (výchozí 1).
Determinant: funkce DET(pole), skalární součin: DOT(p1, p2) (1D pole jménem).

NEXT — viz FOR. ON GOTO / ON GOSUB / ON ERROR

ON volba GOTO 100, 200, 300
ON ERROR GOTO 900
...
900 PRINT "Chyba na "; ERL; ": "; ERRORSTATUS$
910 RESUME NEXT

Hodnota se ořízne na celé číslo; 1 = první řádek v seznamu. Mimo rozsah → pokračuje se dalším příkazem.
ON ERROR GOTO n zachytává běhové chyby: skočí na řádek, ERL = řádek chyby, ERRORSTATUS$ = text chyby. ON ERROR GOTO 0 zachytávání vypne. Chyba v obsluze = konec s chybou.
RESUME (i RESUME 0) = znovu chybný řádek, RESUME NEXT = pokračovat za ním, RESUME n = skok. Bez aktivní chyby → ?RESUME without error.

OPEN / PRINT# / INPUT# / LINE INPUT#

OPEN "O", 1, "VYSTUP.TXT"
PRINT #1, jmeno$; ","; vek
CLOSE 1
OPEN "VYSTUP.TXT" FOR INPUT AS #1
LINE INPUT #1, radek$
CLOSE 1

Režimy: O/OUTPUT zápis (maže), I/INPUT čtení, A/APPEND připisování. Jiný režim (vč. RANDOM) → chyba.
ELSE GOTO skočí při chybě otevření (a nastaví ERL).
PRINT # formátuje stejně jako PRINT a končí koncem řádku (CRLF), pokud za posledním výrazem není ; či ,.
INPUT # čte hodnoty oddělené čárkou (i přes více řádků), LINE INPUT # právě jeden řádek. Čtení za koncem → ?Input past end.

Podrobnosti viz kapitola 8.

OPTION

OPTION BASE 0|1 | OPTION DEGREES | OPTION RADIANS

OPTION BASE = dolní mez pro MAT (stejné jako MAT ORIGIN, výchozí 1).
OPTION DEGREES přepne SIN COS TAN ATN na stupně (vstup i výsledek); OPTION RADIANS vrátí radiány (výchozí).

PRINT / ? (vč. PRINT USING)

PRINT [výraz [{;|,} …]] | ? …
PRINT [#n,] USING formát; hodnota [, …]

PRINT "Ahoj "; jmeno$; "!"
PRINT a, b          : REM čárka = další 14znaková zóna
PRINT x;            : REM středník na konci = bez odřádkování
PRINT TAB(10); "x"
PRINT SPC(5); "*"
PRINT               : REM prázdný řádek
PRINT USING "###.##"; 2.12345     : REM "  2.12"
PRINT USING "**$###.##"; 1.23     : REM "****$1.23"
PRINT USING "#.##E+##"; 2345.6    : REM "2.35E+03"

? je zkratka za PRINT (i ?#n, za PRINT #n,).
TAB(n) doplní mezery na sloupec n (číslováno od 1), SPC(n) vytiskne n mezer.
Formát USING: # číslice, . desetinná tečka, * výplň hvězdičkami, $ měna před číslem, úvodní +/- znaménko, E+## exponent. Širší číslo se nerozseká (pole se roztáhne).
Stejný formát používá funkce FORMAT$(hodnota, formát).

PUSH / POP

PUSH výraz|proměnná [, …]
POP | POP počet | POP proměnná [, …] | POP() — funkce

PUSH x, "text", 1+2
POP x            : REM obnoví x
PRINT POP()      : REM vrátí hodnotu bez obnovy

Vnitřní zásobník (i pro rekurzi). Pole se ukládá kopií.
POP bez parametru obnoví 1 odloženou proměnnou; s číslem N kusů; se jmény najde a obnoví dané (pole i skaláry). Funkce POP() jen vrátí hodnotu. Prázdný zásobník → ?Stack empty.

RANDOMIZE

RANDOMIZE [výraz]

Nastaví semínko generátoru (RND(záporné) ho nastaví také). Stejné semínko = stejná posloupnost. Bez parametru náhodné semínko.

READ — viz DATA. REM

REM text | ' text | ` text

Komentář do konce řádku.

RESTORE — viz DATA. RETURN — viz GOSUB. SELECT CASE

SELECT CASE výraz
[CASE hodnota [, …]
příkazy…]
[CASE ELSE
příkazy…]
END SELECT

SELECT CASE volba$
CASE ""
CASE "k"
  PRINT "konec"
CASE "1", "2"
  PRINT "volba 1 nebo 2"
CASE ELSE
  PRINT "neznámá volba"
END SELECT

Porovnává se textově i číselně; shoda prvního CASE vyhrává, ostatní se přeskočí (i vnořené bloky se párují správně).
CASE mimo SELECT → ?CASE without SELECT.

STATIC — viz SUB. STOP / SYSTEM — viz END. WHILE / WEND

WHILE podmínka … WEND [výraz]

WHILE NOT EOF(1)
  LINE INPUT #1, r$
  PRINT r$
WEND

Nesplněná podmínka při vstupu = přeskočení celého těla na WEND.
WEND výraz: je-li výraz pravdivý, cyklus ihned končí (jinak se pokračuje testem podmínky).
WEND bez WHILE → ?WEND without WHILE; chybějící WEND → ?WHILE without WEND.

Nepodporováno: grafika/zvuk (SCREEN PSET LINE CIRCLE PLAY SOUND BEEP MORSE SAY), náhodný přístup (GET # PUT # → chyba), databáze DBM$, objektový systém (TYPE CLASS), MAT FFT, PEEK POKE VARPTR FRE, sockety/roury (OPEN "pipe:…"/"socket:…"), kurzorové HTAB VTAB GOTOXY POS.

7. Funkce

Volání: JMÉNO(parametry). Parametry jsou výrazy; číselné se převádějí Number(), textové String(). Neznámá funkce s prázdnými závorkami u pole vrací prvek, jinak 0. Funkce bez parametrů lze psát i bez závorek (TIMER, TIME$, PI…).

Matematika

Funkce	Parametry	Vrací	Příklad
`ABS(x)`	číslo	\|x\|	`ABS(-3)` → 3
`SGN(x)`	číslo	1 / 0 / -1	`SGN(-5)` → -1
`INT(x)`	číslo	dolní celá část (k −∞)	`INT(3.9)` → 3, `INT(-3.1)` → -4
`INT(x, 0)`	číslo, cokoli	ořez k nule	`INT(-3.9, 0)` → -3
`FLOOR(x)`	číslo	dolní celá část (k −∞)	`FLOOR(-3.1)` → -4
`FIX(x)`	číslo	ořez k nule	`FIX(-3.9)` → -3
`SQR(x)` (i `SQRT`)	x ≥ 0	odmocnina	`SQR(16)` → 4
`LOG(x)` / `LOG10(x)`	x > 0	přirozený / desítkový logaritmus	`LOG10(1000)` → 3
`EXP(x)`	číslo	e^x	`EXP(0)` → 1
`SIN(x)` `COS(x)` `TAN(x)`	radiány (nebo stupně po `OPTION DEGREES`)	funkce	`SIN(0)` → 0
`ATN(x)` / `ATN(x, y)`	číslo / bod (x,y)	arcustangens / úhel vektoru (x,y); po DEGREES ve stupních	`ATN(1,1)` → 0.785…
`PI`	—	3,141592653589793	`2 * PI`
`RND` / `RND(1)`	— / 1	desetinné 0 (včetně) – 1 (bez)	`RND`
`RND(n)`, n > 1	horní mez (celá část)	celé 0 – n-1	`RND(6)+1` → kostka 1–6
`RND(0)` / `RND(záporné)`	— / semínko	poslední hodnota / nastaví semínko a vrátí novou hodnotu

Řetězce

Funkce	Parametry	Vrací	Příklad
`LEN(s$)`	text	počet znaků (0 u `""`)	`LEN("abc")` → 3
`LEFT$(s$, n)`	text, počet (záporný → 0)	prvních n znaků	`LEFT$("ahoj",2)` → "ah"
`RIGHT$(s$, n)`	text, počet	posledních n znaků	`RIGHT$("ahoj",2)` → "oj"
`MID$(s$, od [, délka])`	text, pozice od 1, nepovinná délka	podřetězec (bez délky až do konce)	`MID$("ahoj",2,2)` → "ho"
`INSTR(s$, hled)`	text, hledaný text	pozice od 1, 0 = nenalezeno	`INSTR("ahoj","o")` → 3
`INSTR(start, s$, hled)` / `INSTR(s$, hled, start)`	obě pořadí povolena	hledá od pozice start	`INSTR("ahoj o","o",4)` → 6
`STRING$(n, x)`	počet, znak nebo jeho kód	znak zopakovaný n-krát	`STRING$(5,"")` → "****"
`SPACE$(n)`	počet	n mezer	`"a"+SPACE$(2)+"b"`
`CHR$(n)` (i `CHR`)	kód (maska & 255)	znak	`CHR$(65)` → "A", `CHR$(27)` = ESC
`ASC(s$)`	text (prázdný → 0)	kód prvního znaku	`ASC("A")` → 65
`VAL(s$)`	text (i výraz v textu)	hodnota: celý výraz, jinak úvodní číslo, jinak 0	`VAL("1+2*3")` → 7, `VAL("12abc")` → 12
`STR$(n)` / `STR$(n, délka)`	číslo, nepovinná šířka	text (nezáporná s mezerou vpředu), s délkou doplněno mezerami zleva	`STR$(5,4)` → " 5"
`FORMAT$(hodnota, formát)`	číslo, formátovací řetězec	formátováno jako `PRINT USING`	`FORMAT$(2.12345,"###.##")` → " 2.12"
`LTRIM$(s$)` `RTRIM$(s$)`	text	ořez mezer zleva / zprava
`UCASE$(s$)` `LCASE$(s$)` (i `UPPER$ LOWER$ UCASE`)	text	velká / malá písmena	`LCASE$("Ahoj")` → "ahoj"
`OCT$(n)`	číslo (ořez dolů)	osmičkový zápis	`OCT$(8)` → "10"
`HEX$(n [, délka])`	číslo, nepovinná šířka	VELKÝ šestnáctkový zápis, s délkou doplněn nulami zleva	`HEX$(15,4)` → "000F"
`BIN$(n [, délka])` (i `BIN`)	číslo, nepovinná šířka	dvojkový zápis, s délkou doplněn nulami	`BIN$(5,8)` → "00000101"
`FIELD$(text, n [, oddělovač])`	text, číslo pole od 1, znak (výchozí mezery jako awk)	n-té pole, jinak `""`; n = -1 → počet oddělovačů	`FIELD$("1 22 333",3)` → "333"
`BSWAP16(n)` `BSWAP32(n)`	číslo	prohozené bajty 16/32bitové hodnoty	`BSWAP16(1)` → 256

Pole a matice

Funkce	Parametry	Vrací
`ISARRAY(pole)`	jméno	počet rozměrů, jinak 0
`UBOUND(pole [, rozměr])`	jméno, číslo rozměru od 1 (výchozí 1)	maximální index (= rozměr z `DIM`), jinak 0
`DET(pole)`	jméno čtvercové 2D matice	determinant
`DOT(p1, p2)`	jména 1D polí	skalární součin (po kratší délku)

Soubory, čas, systém

Funkce	Parametry	Vrací
`EOF(n)` (i `EOF(#n)`)	číslo souboru	-1 = konec (až po pokusu číst za koncem), 0 = lze číst; neotevřený → -1; `#` se ve výrazech ignoruje, takže `EOF(#1)` = `EOF(1)`
`LOF(n)` (i `LOF(#n)`)	číslo souboru	délka obsahu v znacích, neotevřený → 0
`FGETBYTE(n)`	číslo souboru	bajt 0–255 na znakové pozici (posun), za koncem -1
`INPUT$(n [, #f])`	počet, číslo souboru	n znaků ze souboru; bez souboru `""`
`INKEY$`	—	vždy `""` (prohlížeč neumí neblokující klávesu; použijte `GET`/`INPUT`)
`EOL(n)`	číslo souboru	znak konce řádku (`CHR$(10)`)
`TIMER` (i `TIMER()`)	—	celé sekundy od půlnoci 0–86399
`TIME$` (i `TIME`, i s `()`)	—	aktuální čas `HH:MM:SS`
`DATE$` (i `DATE`, i s `()`)	—	aktuální datum a čas v Chipmunk formátu `Www Mmm dd hh:mm:ss yyyy`, např. `Wed Sep 16 12:52:12 2026`; čas se získá `mid$(date$,instr(date$,":")-2,8)`
`ERL`	—	číslo řádku poslední zachycené chyby (`ON ERROR`), jinak 0; lze i zapisovat
`ERRORSTATUS$`	—	text poslední zachycené chyby
`SPC(n)` `TAB(n)`	počet / sloupec	mezery (i mimo `PRINT`)
`VERSION$` (i `VERSION$()`)	—	verze interpretru, např. `PEBASIC 1.0 (JS, LE)`
`BIGENDIAN`	—	vždy 0 (little-endian)
`SYSTEM$(…)` `GETENV$(…)` `ARGV$`	—	vždy `""` (prostředí prohlížeče)
`POP()`	—	hodnota ze zásobníku (`PUSH`); prázdný → `?Stack empty`

8. Soubory podrobně

Úložiště: paměť prohlížeče (localStorage, klíč pebasic_files). Jména se ukládají velkými písmeny (data.txt = DATA.TXT).
Číslo souboru (#n): libovolné celé číslo ≥ 0. Režimy: O/OUTPUT = nový prázdný (přepíše), I/INPUT = čtení existujícího (neexistující = prázdný), A/APPEND = připisování za stávající obsah.
Čtení je sekvenční s ukazatelem; CLOSE u O/A zapíše obsah do paměti. Bez CLOSE se zapsaná data neuloží!
Řádky se dělí podle konců řádků; zapisuje se CRLF (\r\n).
Znakové čtení (INPUT$/FGETBYTE) má vlastní pozici od otevření; řádkové čtení ji sesynchronizuje na aktuální řádek.

Typický vzor kopie souboru:

OPEN "SEZNAM.TXT" FOR INPUT AS #1
OPEN "O", 2, "KOPIE.TXT"
WHILE NOT EOF(1)
  LINE INPUT #1, r$
  PRINT #2, r$
WEND
CLOSE 1 : CLOSE 2

9. SYS — emulace shellu

Volání systému se v prohlížeči emulují prací se soubory v paměti. Cíl přesměrování (> soubor) se bere z příkazu:

Příkaz	Emulace
`SYS("date +%z > soubor")`	zapíše časové pásmo prohlížeče, např. `+0100` (výchozí `TZ.TMP`)
`SYS("date +%u > soubor")`	zapíše den v týdnu 1–7 (Po–Ne, výchozí `DAY.TMP`)
`SYS("ls soubor > ven")`	zapíše jméno, pokud soubor existuje, jinak prázdné (výchozí `CHECK.TMP`)
`SYS("wget URL -O soubor")`	pokus o stažení adresy (typicky selže na CORS — cíl se nezmění a vypíše se důvod)
`SYS("tr -d '\r' < vstup > výstup")`	odstraní CR ze vstupního souboru; prázdný vstup = cíl se nezmění

10. Přímý režim

Po skončení programu je ve fullscreen okně (run.html) aktivní přímý režim — klasická výzva BASICu. S prázdným programem startuje fullscreen rovnou v něm. V hlavním okně (editor) přímý režim není, tam je jen výstup programu. Nápověda: help (i ?).

Ready - primy rezim: help pro napovedu
print 1+2
 3
list
10 PRINT "Ahoj"
...
RUN

`RUN [řádek]`	spustí program (volitelně od řádku)
`LIST [n[-m]]`	vypíše program (celek / řádek / rozsah; `LIST 2-`, `LIST -5`)
`NEW` / `CLEAR`	smaže proměnné a pole (program zůstává)
`LOAD "soubor"` / `SAVE "soubor"`	načte / uloží program ze souboru v paměti
`MERGE "soubor"`	přimíchá řádky ze souboru (stejná čísla přepíše)
`DEL n[-m]`	smaže řádek / rozsah
`RENUM [nový[,krok[,od[,do]]]]`	přečísluje (výchozí 10,10,vše) včetně odkazů `GOTO GOSUB THEN ELSE ON RESTORE RESUME`; kolize → chyba
`FILES`, `CLS`, `EXIT`/`QUIT`/`BYE`	soubory / smazání / konec přímého režimu
`help` / `?`	nápověda přímého režimu
`10 PRINT 1`	řádek s číslem se přidá do programu (stejné číslo = nahrazení; jde to i z prázdného režimu — první řádek program založí)
`10`	holé číslo smaže řádek 10
`PRINT 1+2` apod.	příkaz bez čísla se provede hned (proměnné se sdílí s programem)

11. Chybové hlášky

Formát: ?zpráva, u běžícího programu s řádkem: ?zpráva at line N. Přehled:

Hláška	Kdy
`Syntax error[: …]`	nerozpoznaný příkaz, špatný `FOR/OPEN/INPUT#…`, chybějící `THEN`, špatný `CALL/RESUME/OPTION…`; ve výrazu i zbytek za výrazem (`PRINT 1 2`), chybějící operand (`X = 5 +`) a neznámý znak
`Division by zero`	`/`, `\` i `MOD` nulou
`Undefined line number n`	`GOTO/GOSUB/ON/IF/RESUME…` na neexistující řádek
`Undefined SUB: jméno` / `SUB without END SUB`	volání / definice subrutiny
`Out of DATA`	`READ` za koncem dat
`File already open n`	druhé `OPEN` stejného čísla bez `CLOSE`
`Bad file mode …`	neznámý režim `OPEN` / zápis do souboru otevřeného pro čtení
`File not open n` / `File not found`	operace se zavřeným číslem / `NAME`/`LOAD` neexistujícího
`Input past end`	čtení za koncem souboru
`NEXT without FOR` / `WEND without WHILE` / `RETURN without GOSUB` / `CASE without SELECT` / `END SUB without SUB`	ukončovač bez zahájení
`WHILE without WEND` / `IF without ENDIF` / `ELSE without ENDIF` / `CASE without END SELECT`	neuzavřený blok
`RESUME without error`	`RESUME` mimo obsluhu chyby
`Stack empty` / `POP: variable not on stack`	zásobník `PUSH/POP`
`Array not dimensioned: X` / `Matrix dimensions mismatch` / `Singular matrix` / `MAT supports only 1D/2D arrays`	maticové operace
`GET/PUT random access not supported` / `Random access files not supported`	náhodný přístup k souborům
`MID$/FIELD$ needs string variable`	přiřazení do ne-řetězcové proměnné
`Redo from start`	není chyba, ale opakovaný dotaz po špatném čísle v `INPUT`
`Too many steps (infinite loop?)`	bezpečnostní limit 5 000 000 kroků — typicky nekonečná smyčka
`No program`	spuštění prázdného programu
`Break`	přerušení tlačítkem STOP / Ctrl+C

12. Limity a rozdíly proti Chipmunk / GW-BASIC

Bez grafiky a multimédií (SCREEN PSET LINE CIRCLE GRAPHICS SOUND MORSE SAY SPRITE).
Bez hardwaru a OS věcí (PEEK POKE VARPTR FRE, FN PID/PPID/UID/SLEEP/SHMEM/SYSFORK, sockety/roury, kurzor HTAB VTAB GOTOXY POS). INKEY$ SYSTEM$ GETENV$ ARGV$ vrací "".
Bez náhodného přístupu k souborům, bez DBM$ databází, bez objektového systému (TYPE CLASS), bez MAT FFT, bez CONT a editorových EDIT.
Pravda = 1 (po chipmunkovsku), NOT je logický.
RND sémantika dle Chipmunk (viz tabulka); bez RANDOMIZE startuje náhodně.
PRINT USING/FORMAT$ aproximace (čárky ve formátu se ignorují).
Tělo FOR proběhne vždy aspoň jednou (počáteční mez se netestuje).
Limit běhu 5 000 000 kroků; hloubka GOSUB/CALL a velikost programu omezena jen pamětí.
Délka řádku, řetězců i souborů omezena jen pamětí prohlížeče.