Popis jazyka X

Copyright (c) 2000 Mirek Janata

Co je jazyk X

X je programovací jazyk integrovaný v prostředí serveru FastX. Vyznačuje se jednoduchou syntaxí, modularitou, orientací na manipulaci s textem a SQL databázemi. Je interpretovaný, přesto však mimořádně rychlý, neboť se spouští kompilovaný byte-code. Po posledních optimalizacích správy paměti vykazují testy až desetinásobnou rychlost zpracování oproti VB Skriptu na identických úlohách. Měření porovnávalo rychlost generování dynamických HTML stránek vytvořených ve formě ASP (Active Server Pages) s HP (FastX Hyper Pages) .

X je prvoplánově zaměřeno na SQL a práci s textem. Zkompilované moduly (X moduly) mohou v rámci Freelance-FastX architektury vystupovat v několika různých kontextech:

o Autonomní X moduly zpravidla implementují jednu anebo více funkcí (služeb), které klient vyvolává explicitně buď z příkazové řádky prohlížeče, anebo nepřímo prostřednictvím Freelance

o WRO X moduly jsou specializované moduly, které automaticky nahrává WRO procesor a volá funkce podle předem definovaného rozhraní. Tyto moduly se podílejí na generování WRO reportů, především na výpočetní operace, které nelze prostou WRO šablonou implementovat. Ve Freelance Developeru jsou zpřístupněny nabídkou Report Master/Rozšiřující X moduly...

o WTO X moduly jsou specializované moduly, které automaticky nahrává WTO procesor a volá funkce podle předem definovaného rozhraní. Rozhraní těchto modulů tvoří sada funkcí, které implementují side-efekty spojené s ukládáním změn v editačních tabulkách, zpravidla další databázové operace. Ve Freelance Developeru jsou zpřístupněny nabídkou Table Master/Rozšiřující X moduly...

o hp stránky jsou dynamické HTML stránky, které kromě HTML kódu obsahují i sekci X kódu. HTML kód se může speciálními značkami odkazovat na funkce v X kódu a naopak tyto funkce mohou generovat HTML kód.

Struktura X (runtime) modulu

Zkompilovaný X modul je uložen v jediném souboru s příponou xr. Soubor má hlavičku, která specifikuje vlastnosti X modulu, tedy například zda obsahuje ladící informace, zda překrývá jiný modul a pokud ano, pak jméno tohoto modulu, dále seznam a typy statických proměnných, hodnoty a typy konstant, seznam funkcí a jejich atributy ( počet a popis parametrů, odkaz na začátek programového kódu funkce ) a konečně X operátory.

Nahrávání a spouštění X modulu (bez překrytí)
Při nahrávání či spouštění modulu X runtime nejprve načte informace z hlavičky, pak alokuje paměť pro zásobník, statická data, funkce a kód, dále čte popis statických proměnných a konstant a inicializuje podle nich datovou oblast. Dále čte popis funkcí a inicializuje odpovídající paměťové struktury. Nakonec čte popis operátorů a vytváří podle nich kódovou oblast. Spouští-li se modul, pak se buď vyvolá exportovaná funkce identifikovaná ordinálním číslem anebo, existuje-li, funkce main.
X kompilátor vypisuje po úspěšné kompilaci seznam exportovaných funkcí včetně ordinálních čísel.

Nahrávání a spouštění X modulu (s překrytím – overlapping module)
Zjistí-li X runtime z hlavičky modulu, že překrývá jiný modul, hledá překrývaný modul v seznamu předem nahraným modulů (Preloaded Module Cache). Tento seznam definuje aplikační blok loadX, viz AppMaster. Pokud překrývaný modul nalezne, vytvoří jeho klon neboli kopii a doplní o proměnné, funkce a kód překrývajícího modulu. Deklaruje-li překrývaný modul abstraktní funkce a jsou-li tyto funkce definovány překrývajícím modulem, pak správně nastaví jejich odkazy do programového kódu.
Obecně platí, že overlap technika je z hlediska režie na spuštění modulu úspornější než include technika, protože cílový modul je menší a tudíž se i klonem překrývaného modulu natáhne rychleji. Navíc poskytuje výhodu v možnosti psaní generických modulů, které deklarují a volají funkce, definované v překrývajících modulech. Nevýhoda overlap techniky spočívý v nutnosti překompilovat překrývající moduly po změně překrývaného modulu. Z toho dále plyne nutnost publikovat spolu s upgrade překrývaného modulu i jeho zdrojový kód.

Důležité parametry X modulu

Maximální počet všech objektů (statických proměnných a konstant + funkcí + operátorů) : 65535

Maximální počet statických proměnných a konstant: 2048

Maximální hloubka zásobníku (jeden každý parametr a lokální proměnná libovolného typů má velikost 1): 1024

X kompilátor pro kontrolu vypisuje po úspěšné kompilaci počet statických proměnných+konstant, počet funkcí i počet operátorů.

Programování v jazyce X aneb Od slov k činům...

Zdrojový kód X modulu tvoří následující prvky:

Statické proměnné – deklarují se v bloku variables.

Deklarace funkcí – deklarují se v bloku prototypes.

Deklarace importovaných funkcí – deklarují se v blocích import <jméno dll knihovny>.

Definice funkcí.

Komentáře – jednotlivé řádky začínající symbolem //

Příkazy kompilátoru – jednotlivé

Jednotlivé bloky a funkce jsou vymezeny složenými závorkami.

Datové typy

X podporuje typy (signed 32bit) long, (64bit)double a string. Obory hodnot long a double jsou ekvivalentní implementaci ANSI C. Kromě toho disponuje operátory pracujícími s adresami proměnných.

Statické proměnné

X runtime po natažení modulu všechny statické proměnné inicializuje následujícím způsobem: typ long a typ double naplní hodnotou 0 (nula) a string hodnotou ‘’ (prázdný řetězec).

Příklad deklarace statických proměnných:

variables{
    long longVar
    double doubleVar
    string stringVar
}

Deklarace funkcí

Funkce se deklarují v bloku prototypes. Deklarace samotná je nepovinná, má však smysl především v následujících případech:

Dvě funkce volající se navzájem – alespoň jedna z nich musí být deklarována v prototypech, neboť volání jedné z funkcí předchází její definici.

Exportované funkce – pokud modul exportuje funkce, je nanejvýš žádoucí je deklarovat, neboť se tím pevněji etabluje stabilní systém přidělování ordinálních čísel. Může se totiž stát, že pozdější úpravy modulu zahrnou nové funkce, definované nikoli na konci modulu, ale třeba na začátku anebo uprostřed, které by změnily pořadí kompilace předem nedeklarovaných funkcí a tím pádem i jejich ordinální čísla. Proto je vhodné všechny exportované funkce deklarovat.

Abstraktní funkce – modul je překrývaný, deklaruje a volá funkce, definované až překrývajícími moduly - abstraktní funkce.

Příklad deklarace funkcí:

prototypes{
    long funkce1( string s, long n, double d )
    double funkce2( const string s, long n, double & d )
    string funkce3( string & s, long & n, double d )
}

Deklarace parametrů funkcí

Parametry funkce se deklarují jako čárkami oddělený seznam prvků [const] <datový typ> [&] <jméno parametru>. Parametry se v závislosti na deklaraci předávají třemi způsoby:

o jako konstanta - deklarátor const . Tento způsob je nejrychlejší, hodnotu parametru nelze ve funkci modifikovat.
Příklady: const string par1, const long par2

o hodnotou - bez deklarátoru a symbolu & pro referenci. Je-li hodnota parametru funkcí modifikována, tato změna se ve volající funkci nepromítne. Tento způsob je nejpomalejší. Má však tu výhodu, že parametr, po využití jeho původní hodnoty, lze používat jako lokální proměnnou.
Příklady: string par1, long par2

o odkazem - se symbolem & pro referenci. Je-li hodnota parametru funkcí modifikována, tato změna se ve volající funkci promítne ve změně hodnoty proměnné, odpovídající tomuto parametru.
Příklady: string & par1, long & par2

Deklarace importovaných funkcí

Jazyk X může volat funkce exportované dll knihovnami ( extern ”C” konvence ). Funkce se deklarují v blocích import. Pro parametry jsou přípustné následující datové typy:

Jazyk C	Jazyk X
(signed/unsigned) char	long
(signed/unsigned) int, long [*]	long [&]
double [*]	double [&]
char * (LPSTR)	string

Příklad deklarací importovaných funkcí:

import user32{
    long MessageBoxA( long hParent, string text, string title, long options )
}

import my_dll{
    double my_function( long & lpLong, long options, double & lpDouble )
}

Definice funkcí

Funkce začíná deklarací, tedy podobně jako deklarace prototypu. Deklarace definuje návratovou hodnotu, jméno a případně parametry. Za deklarací následuje znak { a na dalším řádku pak začína tělo funkce. Definice funkce končí znakem } na samostatném řádku. Každý operátor musí být na samostatném řádku.

Příklad definice funkce:

long funkce1( string s, long n, double d )
{
    long l, m, n
    double d
    string s
    =( s, ‘Hello’ )
    ++( l )
    =( d, -123.456 )
}

Jako první se v těle funkce deklarují lokální proměnné. X runtime inicializuje lokální proměnné stejně, jako statické, tedy: typ long a typ double naplní hodnotou 0 (nula) a string hodnotou ‘’ (prázdný řetězec). Pak zavolá kód funkce.

Funkce jako parametr

Parametrem celé řady X operátorů může být i funkce. Je-li tomu tak, zapisuje se stejně jako proměnná - tedy bez závorek - a má-li nějaké parametry, píší se jako další parametry volání X operátoru, tedy:

<operátor>( [<parametry>], <jméno funkce>[,<parametry funkce>] )

Příklady volání funkce funkce1(...) z předchozího příkladu:

=( nLongVar, funkce1, sVar, 123456, 1.112 )

+( nLongVar, funkce1, sVar, 123456, 1.112 )

Návrat z funkce

Každá funkce deklaruje typ své návratové hodnoty. Explicitní ukončení funkce spolu s nastavením návratové hodnoty provádějí operátory xret( <[const]value> ) a return (<[const/function]value>). Rozdíl mezi nimi spočívá v tom, že parametrem operátoru return() může být i funkce. Pokud funkce nevolá některý z těchto operátorů, ukončí činnost se svým posledním operátorem a návratová hodnota není definována.

Větvení toku programu

Jazyk X disponuje sadou příkazů pro větvení; jedná se o příkazy if ... else ... end. Tyto příkazy samozřejmě mohou být i vnořené.

Seznam souvisejících operátorů

Operátor	Popis
if (<[const/function]variable>)	Pokud je hodnota výrazu neprázdná ( != 0, != '' ), proveď blok, jinak vykonej blok else, je-li definován.
if! (<[const/function]variable>)	Pokud je hodnota výrazu prázdná ( != 0, != '' ), proveď blok, jinak vykonej blok else, je-li definován.
	Pokud je variable1 menší než variable2, proveď blok, jinak vykonej blok else, je-li definován.
if<= (<[const]variable1>, <[const]variable2>)	Pokud je variable1 menší nebo roven variable2, proveď blok, jinak vykonej blok else, je-li definován.
else	Blok, který je proveden, není-li splněna podmínka bloku if*.
end	Operátor označuje dolní konec if* bloku
ifcall(<[const]variable1>, <function> )	Operátor, který kondenzuje podmíněné volání funkce do jediného příkazu.

Příklad porovnání řetězců:

long compare_strings( string s, t )
{
    if=( s, t )
        xret( 0 )
    else
        if<( s, t )
            xret( -1 )
        end
    end
    xret( 1 )
// sem se program nikdy nedostane, proto si muzeme dovolit malou ukazku ifcall operatoru
    ifcall( s, compare_strings, s, t )
}

Cykly

Existují dva typy cyklů: while ... end a repeat ... end. Rozdíl je v tom, že while je komplexnější, dovoluje definovat složitější podmínky, zatímco repeat pracuje s jedinou long řídící proměnnou jako čítačem a má tedy prakticky nulovou režii na řízení cyklu. Na konci každého cyklu je řídící proměnná automaticky dekrementována.
Jazyk X navíc implementuje dva rychlé iterátory xfor a xwhile, které cyklicky volají funkci, která je jedním z parametrů.

Seznam souvisejících operátorů

Operátor	Popis
while (<[const/function]variable>)	Dokud je hodnota výrazu neprázdná ( != 0, != '' ), pokračuj v cyklu.
while! (<[const/function]variable>)	Dokud je hodnota výrazu prázdná ( != 0, != '' ), pokračuj v cyklu.
while< (<[const]variable1>, <[const]variable2>)	Dokud je variable1 menší než variable2, pokračuj v cyklu.
while<= (<[const]variable1>, <[const]variable2>)	Dokud je variable1 menší nebo roven variable2, pokračuj v cyklu.
repeat (<long variable>)	Dokud je hodnota proměnné větší než nula, prováděj cyklus. Na konci každého cyklu je řídící proměnná automaticky dekrementována.
end	Operátor označuje dolní konec každého cyklu while/ repeat
xfor(<[const]long from>, <[const]long to>, <function> )	Operátor, provádějící iterativní volání funkce. Pracuje s interním čítačem nabývajícím hodnot from-to. Je obdobou klasického cyklu typu for ( i=from; i < to; i++) ...
xwhile(<[const]variable1>, <function> )	Operátor, provádějící iterativní volání funkce. Před každým voláním testuje hodnotu variable1. Je-li prázdná, iterace skončí.

Příklad cyklů:

long cycle( long counter )
{
    repeat ( counter )
        xwebout( 'Counter value is ' $ counter )
    end
// nyní je counter<0 a dokud je větší než -100, probíhá druhá smyčka
    while< ( -100, counter )
        xwebout( 'Counter value is ' $ counter )
        --( counter )
    end
    xfor( 0, 100, compare_strings, 'Text1, 'Text2' )
    xwhile( counter, decrement_counter, counter )
    xret( 1 )
}

Rekurze

Jazyk X podporuje rekurzi a to jak self-referencing, tak vzájemnou. Omezujícím faktorem je hloubka zásobníku, která nesmí přesáhnout 1024 objektů ( parametry + lokální proměnné ).

XIF - dynamická úschovna dat

Jazyk X disponuje speciálním datovým typem XIF, který implementuje dynamickou paměť. Tato paměť má strukturu stromu a jednotlivé položky jsou přístupné plnou cestou tímto stromem, podobně jako se adresují soubory v rámci struktury adresářů. Oddělovač větví je znak | , tedy more. XIF paměť disponuje opreátory pro čtení, zápis položek, procházení položek větve, zjištění jména větve a čtení a zápisu celého stromu do souboru. Jednotlivé položky jsou netypové a lze do nich zapisovat i číst hodnoty všech tří základních datových typů X. Každý spuštěný X modul má svůj vlastní implicitní XIF strom, který se inicializuje automaticky při prvním použití některého z XIF operátorů. Všechny XIF operátory pro čtení a zápis pracují s implicitním XIF stromem. Navíc však lze pracovat i s externím XIFem, nejčastěji v případě, kdy jeden X modul volá externí funkci jiného X modulu a jako parametr mu předá handle vlastního implicitního XIF stromu. XIF tím pádem může fungovat i jako sdílená paměť mezi moduly. Stromy s velkým množstvím položek je vhodné strukturovat, zrychlí se tím přístup k jednotlivým položkám.

Seznam souvisejících operátorů ( žlutě zvýrazněné jsou nejpoužívanější)

Operátor	Popis
xifs=(<long xif_handle>, <[const]string>) xifl=(<long xif_handle>, <[const]long>) xifd=(<long xif_handle>, <[const]double>)	Zápis do XIF položky (string, long, double). Položku identifikuje 1. parametr ( XIF handle ).
xifs(<long xif_handle>, <[const]string>) xifl(<long xif_handle>, <[const]long>) xifd(<long xif_handle>, <[const]double>)	Čtení hodnoty XIF položky do proměnné (string, long, double). Položku identifikuje 1. Parametr ( XIF handle ).
xifsbyname=(<plne jmeno polozky>, <[const]string>) xiflbyname=(<plne jmeno polozky>, <[const]long>) xifdbyname=(<plne jmeno polozky>, <[const]double>)	Zápis do XIF položky (string, long, double). Položku identifikuje 1. parametr - plné jméno.
xifsbyname(<plne jmeno polozky>, <string>) xiflbyname(<plne jmeno polozky>, <long>) xifdbyname(<plne jmeno polozky>, <double>)	Čtení hodnoty XIF položky do proměnné (string, long, double). Položku identifikuje 1. parametr - plné jméno.
xifchilds(<long xif_handle>,<vlastni jmeno polozky>, <string>) xifchildl(<long xif_handle>,<vlastni jmeno polozky>, <long>) xifchildd(<long xif_handle>,<vlastni jmeno polozky>, <double>)	Čtení hodnoty XIF položky dané vlastním jménem a podstromu daného xif_handle do proměnné (string, long, double). Operátory jsou rychlejší, než xif*byname, vhodné, zejména v iteracích.
xifload( <long>, <[const]string> )	Načtení XIF souboru do implicitního XIFu, operátor zapíše handle xifu do long proměnné (1. parametr).
xifsave()	Zápis XIF stromu do souboru. Implicitní XIF musí být pro tento případ inicializován operátorem xifload()
xifname(<xif_handle>, <string1>, <string>)	Operátor zapíše do string1 plné jméno položky, do string2 vlastní jméno, tedy bez plné cesty.
xifchild(<plne jmeno polozky>, <long>)	Operátor zapíše do long proměnné (2. parametr) handle prvního z dětí zadaného bloku (podstromu).
xifnext(<xif_handle>, <long>)	Operátor zapíše do long proměnné (2. parametr) handle následujícího dítěte.
xifisblock(<xif_handle>, <long>)	Operátor zjistí, zda daná XIF položka je či není blok ( podstrom ). Výsledek (1/0) zapíše do long.
xifset(<long xif_handle>)	Operátor nastavý zadaný XIF jako implicitní. Používá se při manipulaci s externím xifem, předaným třeba jako parametr volajícího modulu. Po ukončení manipulace s ním je nezbytné obnovit původní implicitní XIF operátorem xifreset().
xifreset()	Operátor obnoví původní implicitní XIF. Musí být volán symetricky k xifset().

Příklady volání XIF operátorů:

long xifhandlefunc( string s, long n, double d )
{
    long xif_handle
    string s
    long l
    double d
// čtení XIF stromu ze souboru a nastavení jako implicitního
    xifload ( xif_handle, '\\xifs\\my_xif.xif' )
// zápis hodnoty typu string
    xifsbyname=( 'main|value1', 'Hello' )
// čtení hodnoty
    xifsbyname( 'main|value1', s )
// zápis hodnoty typu long
    xiflbyname=( 'main|value2', 1256 )
// čtení hodnoty
    xiflbyname( 'main|value2', l )
// zápis hodnoty typu double
    xifdbyname=( 'main|value3', 1256 )
// čtení hodnoty
    xifdbyname( 'main|value3', d )
// zápis implicitního XIF stromu na disk
    xifsave()
}

Příklad: rekurzivní výpis celého XIF stromu načteného ze souboru:

// POMOCNÁ rekurzivní funkce writeXIF vypíše zadaný XIF strom
long writeXIF( long xif_handle )
{
    long xif_child, is_block
    string s, tmp, name
// zjistit plné jméno zadaného podstromu a přečíst do proměnné s
    xifname( xif_handle, s, tmp )
// přečíst handle první větev stromu
    xifchild( s, xif_child )
// pro všechny děti
    while ( xif_child )
// je položka blok, neboli podstrom ?
        xifisblock( xif_child, is_block )
        if ( is_block )
// je-li blok, neboli podstrom, pak rekurze
writeXIF( xif_child )
        else
// není, => výpis jména a hodnoty
// .. tedy nejprve přečíst hodnotu položky do s
              xifgets ( s, xif_child )
// .. pak přečíst plné jméno do name
              xifgets ( s, xif_child )
              xifname( xif_child, name, tmp )
// .. pak odeslat webem klientovi ( <br> = odřádkování )
              xwebout( name $ ': ' $ s $ '<br>' )
        end
// další položka podstromu
        xifnext( xif_child, xif_child )
    end
}

// funkce main přečte jméno XIF souboru, který je parametrem modulu a odešle jeho obsah web klientovi
long main()
{
    long xif_handle
// čtení XIF stromu ze souboru a nastavení jako implicitního
    xifload( xif_handle, '\\xifs\\my_xif.xif' )
    writeXIF( xif_handle )
}

Textové řetězce - typ string

Typ string slouží k manipulaci s textovými daty. X disponuje operátory pro spojování, porovnávání, prohledávání, náhrady podřetězců, dělení podle zadaného oddělovače apod.

Seznam souvisejících operátorů (žlutě zvýrazněné jsou nejpoužívanější, tyrkysově jsou 'zajímavé')

Operátor	Popis
=( <string>, <[const/function]string> )	Zápis (inicializace) proměnné typu string.
$( <string>, <[const/function]string> ) $( <string>, <[const/function]long> ) xstrappend(<string1>, <[const/function]string>,<[const/function]long n>)	$: Připojení dalšího textového řetězce anebo hodnoty typu long, která je automaticky konvertována. xstrappend: n- násobné připojení řetězce string2 ke string1
xstralloc(<string1>, <[const/function]long size>)	Operátor alokuje paměť pro nový řetězec délky size. Inicializuje ji mezerami a přidělí proměnné string1. Používá se při obyčejně před voláním externích funkcí, které dostávají jako parametr textový buffer.
xcomp( <long>, <[const]string1>, <[const/function]string2>)	Operátor porovná dva řetězce a výsledek zapíše do long (1. parametr): rovnají-li se, potom 0 string1<string2, potom -1 string1>string2, potom 1
xstrlen( <long>, <[const/function]string>)	Operátor zapíše do 1. parametru délku řetězce ( 2. parametr ).
xstrleft( <string>, <[const]string>, <[const]long n>) xstrright( <string>, <[const]string>, <[const]long n>) xstrmid( <string>, <[const]string1>, <[const]long from>, <[const]long n>)	Operátory pro tvorbu podřetězců: přečte n znaků zleva, zprava anebo od zadané pozice ( 0 počínaje )
xstrat( <long>, <[const/function]string1>, <[const/function]string2>)	Operátor zapíše do long proměnné pozici string2 ve string1 ( 0 počínaje ). Není-li nalezen, výsledek je -1.
xstratfrom( <long>, <[const/function]string1>, <[const/function]string2>, <[const]long1>)	Operátor zapíše do long proměnné pozici string2 ve string1 ( 0 počínaje ). Není-li nalezen, výsledek je -1. Prohledávání začíná od pozice long1.
xstrchar( <string>, <[const/function]string1>, <[const/function]long1>)	Operátor zapíše do string proměnné znak ve string1 na pozici long1. Je-li index mimo roysah řetězce, je výsledkem prázdný řetězec.
xstrchar=( <string>, <[const/function]long1>, <[const/function]string character>)	Operátor změní ve string proměnné znak na pozici long1 na hodnotu character.
xstrcharat( <long>, <[const/function]string1>, <[const/function]string character>)	Operátor zapíše do long proměnné pozici znaku character ve string1 ( 0 počínaje ). Není-li nalezen, výsledek je -1.
xstrrepl( <string>, <[const/function]string1>, <[const/function]string2>)	Operátor nahradí všechny výskyty string1 ve string hodnotou string2.
xstrtrim( <string> )	Operátor odstraní v řetězci všechny mezery před prvním a za posledním znakem.
xstrupr( <string> )	Převod na velká písmena.
xstrlwr( <string> )	Převod na malá písmena.
xstrreplsub( <string>, <[const/function]long1>, <[const/function]long2>, <[const/function]string1>)	Operátor nahradí ve string podřetězec od pozice long1 od pozice long2 hodnotou string2.
xstrcut( <string2>, <string1>, <[const]string3>)	Operátor najde ve string1 oddělovač string3. Vše, co je před ním, zapíše do string2, co zbyde za ním do string1 - ten je tedy zkrácen o string2 a oddělovač-string3.
xstrexpcut( <string2>, <string1>, <[const]string3>, <[const]string4>)	Zajímavý operátor podobný xstrcut, orientovaný na manipulaci s textem SQL: string4 je zakončovací symbol prohledávaného podřetězce string1. Je-li prázdný, pracuje se s celým string1. V podřetězci pracuje podobně jako xstrcut, navíc však respektuje syntaxi výrazů, tedy závorky, uvozovky a apostrofy. Používá se kupříkladu k rozdělení SELECT příkazu na jednotlivé komponenty, pak na selektované výrazy apod.
xnum2str( <string>, <[const/function]long> ) xnum2str( <string>, <[const/function]double> )	Operátor konvertuje long aneb double na string.
xstr2num(<long>, <[const/function]string> ) xstr2num (<double>, <[const/function]string> )	Operátor konvertuje string na long aneb double.

Celá čísla - typ long

Typ long implementuje celá čísla v rozsahu –2,147,483,648 až 2,147,483,647. Je to nejrychlejší datový typ, proto je jeho využití preferováno před typem double, který má vyšší režii, zejména na inicializaci proměnných, konverze apod. Typ long lze s výhodou využívat v řídících proměnných, kde ve spojení s operátory repeat, while a optimalizovanými ++() a --() představuje efektivní řízení cyklů s minimální režií. Mimo to je vhodné jej použít ve všech případech, kdy se pracuje s celými čísly z podmnožiny oboru hodnot long.

Seznam souvisejících operátorů ( žlutě zvýrazněné jsou nejpoužívanější)

Operátor	Popis
++(<long>) --(<long>)	Rychlá inkrementace/ dekrementace.
+(<long>, <[const/function]long/double>) -(<long>, <[const/function]long/double>) *(<long>, <[const/function]long/double>) /(<long>, <[const/function]long/double>)	Přičtení/ odečtení/ násobení/ dělení.
&(<long>, <[const/function]long >) |(<long>, <[const/function]long>) ^(<long>, <[const/function]long>) ~(<long>) <<(<long>, <[const/function]long>) >>(<long>, <[const/function]long>)	Bitové operace: AND, OR, XOR, NOT, SHIFT LEFT, SHIFT RIGHT
xnum2str( <string>, <[const/function]long> )	Operátor konvertuje long aneb double na string.
xstr2num(<long>, <[const/function]string> )	Operátor konvertuje string na long aneb double.

Čísla v plovoucí řádové čárce - typ double

Typ double implementuje celá čísla v rozsahu 1.7E +/- 308 ( 15 číslic ). Je to univerzálnější, nicméně o něco nákladnější datový typ, než typ long. Jeho základní množina operátorů je chudá. Důvodem je fakt, že různé aplikace vyžadují velmi různé operace v pohyblivé řádové čárce a je proto vhodnější importovat potřebné funkce (např. goniometrické - sin, cos...) z runtime knihoven (např. msvcrt.dll).

Seznam souvisejících operátorů ( žlutě zvýrazněné jsou nejpoužívanější)

Operátor	Popis
+(<double>, <[const/function]long/double>) -(<double>, <[const/function]long/double>) *(<double>, <[const/function]long/double>) /(<double>, <[const/function]long/double>)	Přičtení/ odečtení/ násobení/ dělení.
xnum2str( <string>, <[const/function]double> )	Operátor konvertuje long aneb double na string.
xstr2num (<double>, <[const/function]string> )	Operátor konvertuje string na long aneb double.
xnumround(<double>, <[const]long> )	Operátor matematicky double na long desetinných míst.

Logické operátory

Logické operátory implementují logické operace AND, NOT, OR, NAND, NOR, ekvivalenci a nonekvivalenci a jejich vzájemné kombinace.

Seznam souvisejících operátorů

Operátor	Popis
&&(<long>,<[const]variable1>,<[const/function] variable2>) ||(<long>,<[const]variable1>,<[const/function] variable2>) !&&(<long>,<[const]variable1>,<[const/function] variable2>) !||(<long>,<[const]variable1>,<[const/function] variable2>)	Logický AND/ OR/ NAND/ NOR variable1 a variable2. Výsledek (0-1) je zapsán do proměnné long (1. parametr).
==(<long>,<[const]variable1>,<[const/function] variable2>) !=(<long>,<[const]variable1>,<[const/function] variable2>)	Operátor ekvivalence/ nonekvivalence variable1 a variable2. Výsledek (0-1) je zapsán do proměnné long (1. parametr).
!(<long/double>)	Operátor NOT. Je-li číslo nenulové, výsledek je nula a naopak.

Manipulace se soubory

Jazyk X implementuje základní operace nad soubory: vytvoření/ otevření, čtení, zápis a zavření. Kombinuje se s typem string, který se používá jako buffer.

Seznam souvisejících operátorů

Operátor	Popis
xfopen(<long>,<[const]string1>,<[const]string2>)	Otevření souboru: string1=jméno, string2=atributy r(ead)|w(rite)|c(reate). Výsledek (1. Parametr) je file handle anebo -1 ( chyba ).
xfclose(<long>)	Zavření souboru, parametrem je file handle.
xfread(<long>, <long>, <[const]string>, <[const]long>)	Čtení ze souboru. Parametry: počet přečtených byte anebo -1, file handle, buffer, počet bytů. Je-li poslední parametr ( počet byte ke čtení ) -1, operátor sám zjistí zbývající délku souboru a přečte jej do řetězce celý.
xfwrite(<long>, <long>, <[const]string>, <[const]long>)	Zápis do souboru. Parametry: počet přečtených byte anebo -1, file handle, buffer, počet bytů. Je-li poslední parametr ( počet byte ke čtení ) -1, operátor sám zjistí délku řetězce a zapíše jej celý.

Datum, čas

Existují tři operátory které zpřístupňují aktuální datum a čas:

Seznam souvisejících operátorů

Operátor	Popis
xdate(<string>) xtime(<string>) xdatetime(<string>)	Zjištění autuálního datumu, času, datumu a času. Formát je dd.MM.yyyy hh:mm:ss

Ostatní operátory

žlutě zvýrazněné jsou nejpoužívanější, tyrkysově jsou 'zajímavé'

Operátor	Popis
xret(<[const]variable>) return(<[const/function]variable>)	Návrat z funkce a nastavení návratové hodnoty
xstdout(<[const/function]variable>) xstnl()	Výpis dat/ odřádkování na standardní výstup. Implementačně závislý operátor. Ve FastX implementaci se nepoužívá.
xoutputhandler (<function>, <[const]long start>)	Přesměrování výstupu: Operátor nastaví output handler, tedy uživatelsky definovanou redir funkci, která je volána při výpisu dat operátorem xstdout()/ xwebout() - v závislosti na implementaci X. Redir funkce musí deklarovat jediný parametr const string, který je naplněn vypisovaným textem. Redir funkce může provést další zpracování vypisovaného textu, může dále použít operátor xstdout()/ xwebout(), který tentokrát odešle data klientovi.
xloadx(<long xmod>, <[const]string>)	Externí X moduly: Operátor načte X modul identifikovaný cestou k xr souboru a vrátí jeho handle v proměnné xmod.
xrunx(<long>, <[const]long xmod>, <[const]funcid>, <[const]long lparam>, <[const]string sparam>)	Externí X moduly: Volání exportované funkce č. funcid v externím modulu xmod. Operátor přijímá parametry lparam a sparam, které jsou ve volaném modulu přístupné operátory xlparam() a xsparam().
xunloadx(<long xmod>)	Externí X moduly: Uvolnění externího modulu z paměti.
xlparam(<long>) xsparam(<string>)	Externí X moduly: Tyto operátory čtou parametry externího volání funkce anebo X modulu.

Operátory specifické pro FastX implementaci

Výpis dat klientovi

Klientem FastX může být služba Freelance aplikace anebo internetový prohlížeč. Zaměříme se na druhou variantu, která představuje výstup dat v HTML formátu. Operátor xwebout() podporuje výstup libovolného textu, HTML formát je však nejběžnější. Z tohoto hlediska je důležitým faktem, že vypisovaný text musí obsahovat veškeré formátovací značky, xwebout() do obsahu nikterak nezasahuje.

Seznam souvisejících operátorů

Operátor	Popis
xwebout(<[const/function]variable>)	Výpis dat klientovi anebo volání funkce, na kterou je přesměrován výstup. Volá-li se xwebout() z ní, jsou data odeslána klientovi.

Příklad:
long writeHelloPage()
{
    xwebout( '<html><head><title>Hello page</title></head>' )
    xwebout( '<body><h1>Hello world!<h1></body></html>' )
}

Identifikace přihlášeného uživatele

Klienti Freelance/ FastX se mohou identifikovat přímým loginem (Database/User/Pwd), dále prostřednictvím CID anebo UID. Ve všech případech existuje jednotný způsob zjištění identifikačních parametrů.

Seznam souvisejících operátorů

Operátor	Popis
xweblogininfo(<string db>, <string us>, <string pwd>, <string cid>, <string ipadr>)	Operátor zjistí požadovanou databázi, uživatele, heslo, CID a IP adresu klienta. CID můž být -1, je-li klient identifikován přímým loginem anebo UID.

Čtení parametrů příkazu

Většina příkazů Freelance/ FastX klientů obsahuje parametry ve formátu PARAM_NAME1=value1&PARAM_NAME2=value2. V případě Freelance klienta je oddělovačem znak ASCII 7, to však není podstatné. Hodnoty parametrů čte operátor xwebparam().

Seznam souvisejících operátorů

Operátor	Popis
xwebparam(<string value>, <[const]string param_name>)	Operátor zapíše hodnotu parametru param_name do value.

---

Přejít na Freelance Developer Home FDK Home