Programkód¶

Ez a rész a programkód szintaxisát és felépítését írja le.

Szintaxis¶

Megjegyzések¶

Három típus érhető el:

Általános megjegyzés: hagyományos // és /* … */ jelölést használ, Code::Comment csomópont jön létre.
Dokumentációs megjegyzés: //! és /*! … */ jelöléssel, a következő csomóponthoz kötődik.
Negáló vagy diszkvalitív megjegyzés: //- és /*- … */ jelöléssel, a beolvasó figyelmen kívül hagyja, nem tárolódik el.

Kulcsszavak¶

Mivel a szintaxis sem végleges, átmenetileg egy csillaggal (*) kezdődnek a kulcsszavak.

Számformátumok¶

A jelöletlen egész szám alapértelmezésben int32 típust kap, a lebegőpointos float32 típust. A következő utótagok típusai:

«u»: uint32
«s»: int16
«us»: uint16
«l»: int64
«ul»: uint64
«f»: float32
«lf»: float64

Sztringek¶

A sztringek csak kódolt speciális jeleket tartalmazhatnak, nyers sor vége jelet nem. Az egymás után következő sztringek összefűzésre kerülnek.

általános sztring: „” jelek között, Data::String típusú
lefordítható szöveg: _”” jelek között, Data::LangString típusú
karakter a «» jelek között, Data::Char típusú

Logikai értékek¶

Három logikai érték támogatott: true, false, undefined.

Tároló literálok¶

A sima kapcsos zárójel vektor típust jelöl. Specializált tárolókhoz csak homogén tartalom rendelhető.

vektor: *vector{…}, Store::Vector
lista: *list{…}, Store::List
halmaz: *set{…}, Store::Set
térkép: *map{}, Store::Map
bináris tömb: *bin{…}, Store::BinaryArray

Speciális változók¶

A numerikus változó dollár jellel ($) kezdődik és egy egész szám követi, a nevesített változó karakterláncot tartalmaz a dollár után. Behelyettesítéskor használatosak.

Nyers szöveg¶

Nyers szövegrésztet a %{ és }% jelek között adható meg, a közbenső rész nem lesz külön értelmezve.

Speciális elemek¶

*null: Data::Null
*invalid: Data::Invalid

Műveletek¶

Aritmetikai műveletek nyers adatok vagy adat csomópontok között történhet. Az operátor metódus még nem támogatott.

Alapműveletek¶

Támogatott unáris alapműveletek és jelölésük:

negálás (-)
inverz logikai érték (!)
növelés eggyel (++)
csökkentés eggyel (--)

Támogatott bináris alapműveletek és jelölésük:

összeadás (+)
kivonás (-)
szorás (*)
osztás (/)
maradék képzés (%)
hatványozás (^)
«és» bináris művelet (&)
«vagy» bináris művelet (|)
«és» logikai művelet (&&)
«vagy» logikai művelet (||)

Konstans lista¶

Rögzített tartalmú halmaz, sztring összehasonlításra használható. A Store::Set tároló csomópontokat tartalmaz, a konstans lista nyers adatokkal dolgozik, ezért sokkal hatékonyabb. Negálni a ! @ formával lehetséges.

    *if (value @ <("a", "b", "c")>) {
        System::stdout ("Match!\n");
    }

Változók¶

Változót létrehozni típus megadással lehet.

    [attrib] Type identifier;
    [attrib] Type identifier (values...);

Speciális típus a Node amely bármely típusra alkalmazható. Használatát a validátorban tiltani lehet. Hatóköre a kódblokk végéig tart.

Kifejezések¶

Minden kifejezés egy Code::Expression típusú csomópontban található.

Balértékek¶

Nincs implicit típus konverzió.

Operátorok¶

Három típusa van:

unáris: egy operátor és egy operandus
bináris: egy bináris opertor és két operandus
multi: egy bináris operátor és kettő vagy több operandus.

Hivatkozások¶

Paraméter, blokk változó, osztály változó elérése.

Hívások¶

Értékadás vagy állapot változás céljából, paraméter átadással.

Ciklusok¶

Léptető «for» ciklus:¶

    *for (int32 i = 0; i < 10; i++) {
        System::stdout ("%1\n"[i]);
    }

«Foreach» ciklus:¶

    Store::Vector<Data::String> list = {"a", "b", "c"};
    *foreach (Data::String i: list) {
        System::stdout ("%1\n"[i]);
    }

Elöl tesztelő «while» ciklus:¶

    uint32 i = 0;
    *while (i < 10) {
        System::stdout ("%1\n"[i++]);
    }

Hátul tesztelő «until» ciklus:¶

    uint32 i = 0;
    *do {
        System::stdout ("%1\n"[i++]);
    }
    *until (i < 10);

Kondíciók¶

Feltétel:¶

Lehetőség van a hagyományos if/else párok használatára is, vagy a feldolgozást és az összetartozást hatékonyabban elősegítő feltétel láncok kialakítására.

    *if (value == "a") {
        System::stdout ("1\n");
    }
    *elsif (value == "b") {
        System::stdout ("2\n");
    }
    *else {
        System::stdout ("3\n");
    }

«Switch»:¶

Egész típus (int32) és sztring is megadható kulcsnak, de nem keverhető.

    string a = "a";
    *switch (a) {
        *case "a": {
            System::stdout ("1\n");
        }
        *case "b":
        *case "c": {
            System::stdout ("2\n");
        }
        *default: {
            System::stdout ("3\n");
        }
    }

Belépési pont és funkció¶

Mindkettő statikus jellegű, végrehajtásban nem különböznek.

Funkció¶

A funkciók egyszerű sorrendi végrehajtást lehetővé tevő szerkezetek.

    *function bool hello (Data::String message) {
        *if (message.empty())
            *return false;
        System::stdout (message);
        *return true;
    };

Belépési pont¶

A belépési pontnak inkább szemantikai jelentősége van. Kezdetben adatok adhatók át, visszatérése után minden művelet befejezettnek tekinthető és minden erőforrásnak lezárásra kell kerülnie.

Paramétere lehet üres, vagy sztring tömb. A konkrét típus a hívás módjától és a felhasználástól függ. Konzolból is futtatható, de egy cél nyelvre (pl. C++ vagy Python) transzformált állapotban van konkrét jelentősége.

    *entrypoint int main (Store::Vector<Data::String> args) {
        System::stdout ("Hello from %1\n"[args[0]]);
        *return 0;
    };