# 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;
    };
```