Úvod

Dokumentace SP-Langu¤

Vítejte u dokumentace SP-Langu. SP-Lang je zkratka pro Stream Processing Language. SP-Lang je navržen jako intuitivní a snadno použitelný jazyk i pro lidi, kteří nemají zkušenosti s programováním. Snažíme se, aby jeho používání bylo stejně jednoduché jako používání maker v tabulkovém procesoru nebo jazyka SQL, což vám umožní provádět výkonné úlohy zpracování dat s minimálním úsilím.

Hlavním cílem jazyka SP-Lang je, aby za vás udělal mnoho těžké práce, takže se můžete soustředit na to, čeho chcete dosáhnout, a ne se starat o detaily, jak to realizovat. Tento nízkoúrovňový přístup vám umožní rychle začít pracovat, aniž byste se museli učit spoustu složitých programovacích konceptů.

Doufáme, že vám tato dokumentace poskytne všechny informace, které potřebujete k tomu, abyste mohli začít pracovat s naším jazykem a začít využívat jeho výkonné možnosti proudového zpracování. Děkujeme, že jste si vybrali náš jazyk, a těšíme se na to, co s ním dokážete!

Vyrobeno s v TeskaLabs

SP-Lang je technologie vytvářená ve společnosti TeskaLabs.

Úvod¤

SP-Lang je funkcionální jazyk, který používá syntaxi YAML.

SP-Lang poskytuje velmi vysoký výkon, protože je zkompilován do strojového kódu. To mu spolu s rozsáhlými optimalizacemi dává výkon srovnatelný s jazyky jako jsou C, Go nebo Rust; tedy nejvýše dosažitelný.

Z tohoto důvodu je SP-Lang přirozeným kandidátem na nákladově efektivní zpracování masivních datových toků v cloudu nebo v on-premise aplikacích.

Hello world! v jazyce SP

!ADD
- Hello
- " "
- world
- "!"

Stejný příklad ve vizuální podobě SP-Langu

Pro první seznámení s jazykem SP-Lang vyzkoušejte náš tutoriál.

Vlastnosti jazyka SP-Lang¤

📜 Deklarativní jazyk
🔗 Funkcionální jazyk
🔐 Silně typovaný
💡 Typová inference
🐍 Interpretován v jazyce Python
🚀 Kompilován pomocí LLVM
Syntaxe je založena na YAML

Věnování¤

Tato práce je věnována památce mé matky, jejíž víra ve mne byla stejně pevná jako bezpodmínečná. Ačkoli technická stránka návrhu doménového jazyka byla mimo její sféru, její neochvějná víra ve mne byla majákem, který mě provázel.

Její duch, láska a houževnatost ve mně zůstávají, inspirují mě a pohání kupředu. Doufám, že tento jazyk, výtvor mé práce a lásky, je svědectvím jejího nezdolného ducha.

Rád bych také vyjádřil upřímnou vděčnost všem přispěvatelům, jejichž obětavost a odborné znalosti pomohly utvářet tento projekt. Díky vaší spolupráci bylo možné tuto technologii vytvořit.

Děkuji ti, mami. Tohle je pro tebe.
Aleš Teska

Tutoriál k SP-Langu¤

Úvod¤

Vítejte u tutoriálu k SP-Langu. SP-Lang, zkratka pro Stream Processing Language, je doménově specifický jazyk (DSL). Je založen na YAML, člověkem čitelném jazyku pro serializaci dat. Cílem tohoto tutoriálu je představit základní prvky jazyka SP-Lang.

Hello World¤

Začneme jednoduchým příkladem:

---
Hello world!

V jazyce SP-Lang signalizují trojité pomlčky (---) začátek kódu.

Hello world! zde je hodnota, kterou chcete vrátit. V tomto případě je to náš přátelský pozdrav "Hello world!".

SP-Lang je založen na YAMLu¤

SP-Lang je postaven na YAML (Yet Another Markup Language). YAML klade důraz na jednoduchost a čitelnost, což z něj činí skvělý základ pro SP-Lang.

Important

Jazyk YAML ve velké míře stojí na odsazování, které je významné v jeho syntaxi. Jako osvědčený postup doporučujeme používat pro odsazení dvě mezery. Upozorňujeme, že v jazyce YAML nejsou podporovány znaky TAB.

Komentáře¤

Při psaní kódu je užitečné zanechávat komentáře. Usnadníte tak ostatním (a svému budoucímu já) pochopit, co váš kód dělá.

---
# Toto je komentář.
Hello world!

Komentáře v SP-Langu začínají znakem #. SP-Lang ignoruje vše, co následuje za # na stejném řádku, což je užitečné pro přidávání poznámek nebo popisování kódu.

Výrazy SP-Lang¤

Výrazy v jazyce SP-Lang jsou příkazy, které provádějí operace. Podívejme se na příklad s aritmetickými výrazy:

Tento kód sečte dvě čísla, konkrétně vypočítá 5+8.

---
!ADD
- 5
- 8

Výše uvedený výraz sečte dvě čísla, 5 a 8, a získá výsledek 13.

Výrazy v jazyce SP-Lang začínají vykřičníkem (!).

Tip

Výraz "Expression" je alternativní výraz pro funkci.

V tomto příkladu je !ADD výraz pro aritmetické sčítání, které sečte zadaná čísla.

Čísla, která chcete sečíst, jsou zadána jako seznam, protože !ADD je výraz pro posloupnost. To znamená, že může sčítat více vstupních hodnot:

---
!ADD
- 5
- 8
- 9
- 15

Tento seznam vstupních hodnot je vytvořen pomocí pomlčky - na začátku řádku obsahujícího hodnotu. Každý řádek představuje jednotlivou položku seznamu.

Výrazy můžete psát také stručněji pomocí "flow formy", kterou lze libovolně kombinovat s výchozím stylem kódu SP-Lang:

---
!ADD [5, 8, 9, 15]

Mapovací výrazy¤

Dalším typem výrazu je mapovací výraz. Namísto seznamu vstupů používají mapovací výrazy jména vstupů, která lze nalézt v dokumentaci výrazu.

---
!ENDSWITH
what: "FooBar"
postfix: "Bar"

Výraz !ENDSWITH kontroluje, zda hodnota zadaná na vstupu what končí hodnotou zadanou na vstupu postfix. Pokud ano, vrátí true, pokud ne, vrátí false.

I na mapovací výrazy lze použít flow formu:

---
!ENDSWITH {what: "FooBar", postfix: "Bar"}

Skládání výrazů¤

SP-Lang umožňuje kombinovat výrazy a vytvářet tak složitější a výkonnější řešení. Výstup jednoho výrazu můžete vzít za základ pro vstup do jiného výrazu.

---
!MUL
- 5
- !ADD [6, 2, 3]
- 9
- !SUB [10, 5]

Tento příklad je ekvivalentní aritmetické operaci 5 * (6 + 2 + 3) * 9 * (10 - 5).

Argumenty¤

Argumenty jsou způsob, jakým do jazyka SP-Lang předáváme data. V závislosti na kontextu volání může mít výraz žádný, jeden nebo více argumentů. Každý argument má jedinečné jméno.

K hodnotě argumentu můžete přistupovat pomocí výrazu !ARG.

V následujícím příkladu je argumentem výraz name:

---
!ADD ["Hi ", !ARG name, "!"]

Tento výraz bere hodnotu name a vloží ji do řetězce, čímž se vytvoří pozdrav.

Závěr¤

V tomto tutoriálu jsme se seznámili se základy jazyka SP-Lang, včetně toho, jak psát jednoduché výrazy, složené výrazy a jak používat argumenty. S těmito základy jste připraveni začít prozkoumávat složitější definice v jazyce SP-Lang. Při dalším pokračování nezapomeňte hojně využívat dokumentaci, abyste porozuměli různým výrazům a jejich požadovaným vstupům.

Mnoho zdaru při programování!

Syntaxe jazyka SP¤

Info

Syntaxe SP-Lang používá YAML 1.2

Komentáře¤

Komentář je označen indikátorem #.

# Tento soubor neobsahuje žádný
# SP-Lang, pouze komentáře.

Čísla¤

Celá čísla¤

kanonický zápis: 12345
kladné číslo: +12345
záporné číslo: -12345
osmičkový zápis: 0o14
hexadecimální zápis: 0xC

Desetinná čísla¤

pevný zápis: 1230.15
kanonický zápis: 1.23015e+3
exponenciální zápis: 12.3015e+02
záporné nekonečno: -.inf
není číslo: .nan

Řetězce¤

řetězec: '012345'
řetězec bez uvozovek: Řetězec můžete zadat i bez uvozovek.
emoji: 😀🚀⭐

Řetězce s uvozovkami:

unicode: "Sosa se dařilo.\u263A"
control: "\b1998\t1999\t2000\n"
hex esc: "\x0d\x0a je \r\n"

singl: '"Nazdar!" zvolal.'
citováno: ' # Toto není ''komentář''.'

Víceřádkové řetězce:

|
   _____ _____        _                       
  / ____|  __ \      | |                      
 | (___ | |__) |_____| |     __ _ _ __   __ _ 
  \___ \|  ___/______| |    / _` | '_ \ / _` |
  ____) | |          | |___| (_| | | | | (_| |
 |_____/|_|          |______\__,_|_| |_|\__, |
                                         __/ |
                                        |___/

Doslovný styl (označený |) zachovává počáteční mezery.

>
  Rok Marka McGwirea
  byl poznamenán
  zraněním kolena.

Složený styl (označený >) odstraňuje případné odsazení YAML.

Pravdivostní hodnoty (booleans)¤

True boolean: true
False boolean: false

Výrazy¤

Všechny výrazy SP-Lang (alias funkce) začínají na !, výrazy SP-Lang jsou tedy tagy YAML (!TAG).

Výrazy mohou být těchto typů:

Mapování (Mapping)
Posloupnost (Sequence)
Skalár (Scalar)

Mapovací výrazy¤

Příklad:

!ENDSWITH
what: FooBar
postfix: Bar

Příklad použití ve formě flow:

!ENDSWITH {what: FooBar, postfix: Bar}

Specifikace YAML

Viz kapitola 10.2. Styly mapování

Sekvenční výrazy¤

Příklad:

!ADD  
- 1  
- 2  
- 3

Příklad použití ve formě flow:

!ADD [1, 2, 3]

Specifikace YAML

Viz kapitola 10.1. Styly sekvencí

Sekvenční výraz lze definovat také pomocí argumentu with:

!ADD
with: [1, 2, 3]

Tip

Jedná se vlastně o mapovací formu sekvenčního výrazu.

Skalární výrazy¤

Příklad:

!ITEM EVENT brambory

Specifikace YAML

Viz kapitola 9. Skalární styly

Kotvy a aliasy¤

SP-Lang využívá YAML kotvy a aliasy. To znamená, že se můžete odkazovat na výsledek jiného výrazu pomocí kotvy. Kotva je řetězec začínající znakem "&". Výsledek výrazu anotovaného kotvou lze pak znovu použít pomocí aliasu, což je řetězec začínající na "*", následovaný jménem kotvy. Na jednu kotvu se může odkazovat více aliasů.

Příklad:

!ADD
- 1
- &subcount !MUL
  - 2
  - 3
- *subcount
- *subcount

Výsledek je roven 1+(2*3)+(2*3)+(2*3), tedy 19.

Struktura souboru SP-Lang¤

SP-Lang používá tři pomlčky (---) k oddělení výrazů od obsahu dokumentu. Slouží také k signalizaci začátku SP-Langu. Tři tečky ("...") označují konec souboru bez začátku nového, pro použití v komunikačních kanálech.

Přípona souboru SP-Lang je .yaml.

Příklad souboru SP-Lang:

multiplication.yaml

---
# Proveďme nějaké základní matematické výpočty
!MUL
- 1
- 2
- 3

Note

Soubor SP-Lang vždy začíná řádkem ---.

Info

Jeden soubor může obsahovat více výrazů pomocí oddělovače YAML (---).

Jazyk

Design jazyka SP-Lang¤

Vlastnosti¤

Kompilace anebo interpretace

SP-Lang je:

jednak kompilován pomocí LLVM
druhak interpretován v jazyce Python

📜 Deklarativní¤

Většina počítačových jazyků je imperativní.
To znamená, že většina kódu směřuje k tomu, aby počítači vysvětlila, jak má provést nějakou úlohu.
Naproti tomu SP-Lang je deklarativní.
Tvůrce popisuje, "co" chce, aby jeho logika udělala, nikoliv přesně "jak" nebo "kdy" to má být provedeno.
Překladač pak vymyslí, jak to provést.
To kompilátoru umožňuje silně optimalizovat tím, že odkládá práci, dokud není potřeba, předem načítá a znovu používá data z mezipaměti atd.

🔗 Funkční¤

SP-Lang upřednostňuje čisté funkce bez vedlejších efektů.
Výsledkem je logika, která je srozumitelnější a dává kompilátoru největší volnost při optimalizaci.

🔀 Bezstavový¤

Neexistuje žádný stav, který by bylo možné modifikovat, a proto nejsou žádné proměnné, pouze konstanty.
Data procházíte různými výrazy a sestavujete konečný výsledek.

Více informací

🔐 Silně typovaný¤

Typy všech hodnot jsou známy v době kompilace.
To umožňuje včasné odhalení chyb a posílení optimalizace.

💡 Podpora odvozování typů¤

Typy jsou odvozeny z jejich použití, aniž by byly deklarovány.
Například nastavení proměnné na číslo vede k tomu, že typ této proměnné je stanoven jako číslo.
To dále snižuje složitost pro tvůrce bez oběti na výkonu známé z interpretovaných jazyků.

Pro pokročilé uživatele, kteří vyžadují větší kontrolu nad typovým systémem, poskytuje SP-Lang mechanismy pro explicitní určení typů nebo interakci s typovým systémem v případě potřeby.
Tato flexibilita umožňuje pokročilým uživatelům vyladit svůj kód pro maximální výkon a spolehlivost a zároveň využívat pohodlí typové inference.

🎓 Turingovsky úplný¤

SP-Lang je navržen tak, aby byl turingovsky úplný.

Výkon jazyka SP-Lang¤

Úvod¤

SP-Lang je navržen tak, aby poskytoval velmi vysoký výkon.

Interně kompiluje poskytnuté výrazy do strojového kódu pomocí LLVM IR a velkého stupně optimalizací, které jsou možné díky funkcionální struktuře jazyka. Nabízí extrémně vysokou propustnost jednoho jádra procesoru s bezproblémovou schopností škálovat zpracování podle dostupných jader procesoru a plně využívat výhody moderních architektur procesorů.

Výkonnostní testy měří propustnost v EPS, událostech za sekundu. Události za sekundu je termín používaný ve správě IT pro definici počtu událostí, které jsou zpracovány výrazem SP-Lang za jednu sekundu. EPS se měří pro jedno jádro procesoru.

Výkonnostní testy jsou automatizovány pomocí rámce CI/CD, a proto jsou zcela reprodukovatelné.

Porovnávání více řetězců¤

Tento výraz vyhledává prvky konečné množiny řetězců ve vstupním textu. Hodí se např. pro klasifikaci škodlivých adres URL (poskytnutých blokovým seznamem) ve výstupu firewallu.

!IN
  where: !ARG url
  what:
  - ".000a.biz"
  - ".001edizioni.com"
  < 64 domén celkem >
  - ".2win-tech.com"
  - ".2zzz.ru"

Tento seznam poskytuje projekt blackweb.

Jádro jednoho procesoru na HW-M1-20: 1423686 EPS
Jedno jádro CPU na HW-I7-15: 807685 EPS

Parsování JSON¤

!JSON.PARSE
what: |
  {
    < https://github.com/TeskaLabs/cysimdjson/blob/main/perftest/jsonexamples/test.json >
  }

Poznámka

Rychlé parsování JSON je zajištěno projekty cysimdjson, resp. simdjson._.

Jedno jádro procesoru na HW-M1-20: 968502 EPS
Jedno jádro CPU na HW-I7-15: 562862 EPS

Parsování IETF Syslogu¤

Toto je parser IETF Syslog aka RFC5424 implementovaný v SP-Langu:

!PARSE.TUPLE # Hlavička
- !PARSE.EXACTLY {what: '<'}
- !PARSE.DIGITS
- !PARSE.EXACTLY {what: '>'}
- !PARSE.DIGITS
- !PARSE.EXACTLY {what: ' '}

- !PARSE.TUPLE # Časové razítko
  - !PARSE.DIGITS # Rok
  - !PARSE.EXACTLY {what: '-'}
  - !PARSE.DIGITS # Měsíc
  - !PARSE.EXACTLY {what: '-'}
  - !PARSE.DIGITS # Den
  - !PARSE.EXACTLY {what: 'T'}
  - !PARSE.DIGITS # Hodiny
  - !PARSE.EXACTLY {what: ':'}
  - !PARSE.DIGITS # Minuty
  - !PARSE.EXACTLY {what: ':'}
  - !PARSE.DIGITS # Sekundy
  - !PARSE.EXACTLY {what: '.'}
  - !PARSE.DIGITS # Subsekundy
  - !PARSE.EXACTLY {what: 'Z'}

- !PARSE.EXACTLY {what: ' '} # HOSTNAME
- !PARSE.UNTIL   {what: ' '}

- !PARSE.EXACTLY {what: ' '} # APP-NAME
- !PARSE.UNTIL   {what: ' '}

- !PARSE.EXACTLY {what: ' '} # PROCID
- !PARSE.UNTIL   {what: ' '}

- !PARSE.EXACTLY {what: ' '} # MSGID
- !PARSE.UNTIL   {what: ' '}

- !PARSE.EXACTLY {what: ' '} # STRUCTURED-DATA
- !PARSE.OPTIONAL
  what: !PARSE.TUPLE
    - !PARSE.EXACTLY {what: '['}
    - !PARSE.UNTIL   {what: ' '} # SD-ID
    - !PARSE.REPEAT  
      what:
      !PARSE.TUPLE # SD-PARAM
      - !PARSE.EXACTLY {what: ' '}
      - !PARSE.UNTIL   {what: '='} # PARAM-NAME
      - !PARSE.EXACTLY {what: '='}
      - !PARSE.BETWEEN 
         what: '"'
         escaped: '\\"]'

Jádro jednoho procesoru na HW-M1-20: 304004 EPS
Jedno jádro CPU na HW-I7-15: 181494 EPS

Referenční hardware¤

HW-M1-20¤

Stroj: MacBook Air (M1, 2020)
CPU: Apple M1, uveden na trh v roce 2020

HW-I7-15¤

Stroj: MacBook Pro (15palcový, 2016)
CPU: 2.6 GHz Quad-Core Intel Core i7, I7-6700HQ, uveden na trh v roce 2015

Schéma¤

Schémata v SP-Langu popisují typ a další vlastnosti polí v dynamicky typovaných kontejnerech, jako je JSON nebo pythonovské slovníky.

Je důležité poskytnout SP-Langu informace o typu, protože se používají jako vstup pro typovou inferenci, a tedy pro optimální výkon.

Definice schématu¤

Reprezentace schématu ve formátu YAML:

---
define:
  type: splang/schema

fields:
  field1:
    type: str
    aliases: ["FieldOne"]

  field2:
    type: ui64

Možnosti¤

Možnost `type`¤

Definuje datový typ daného atributu, například str, si64 a podobně. Další informace naleznete v typovém systému SP-Langu.

Tato volba je povinná.

Možnost `aliases`¤

Definuje aliasy polí pro daný atribut, které lze použít v deklaraci jako synonymní výraz.

Pokud má pole field1 alias pole s názvem FieldOne, jsou následující deklarace rovny, pokud je schéma správně definováno:

!GET
what: field1
from: !ARG input

!GET
what: FieldOne
from: !ARG input

Možnost `unit`¤

Definuje jednotku atributu, pokud je potřeba, například pro časové značky. V tomto případě může být jednotka auto pro automatickou detekci, sekundy a mikrosekundy.

Deklarace funkce (Python)¤

Příklad deklarace funkce SP-Lang, která používá MYSCHEMA.yaml:

splang.FunctionDeclaration(
    name="main",
    returns="bool",
    arguments={
        'myArgument': 'json<MYSCHEMA>'
    },
)

a samotný soubor MYSCHEMA.yaml:

---
define:
  type: splang/schema

fields:
  field1:
    type: str

  field2:
    type: ui64

In-place schémata¤

SP-Lang umožňuje specifikovat schéma přímo v kódu FunctionDeclaration jazyka Python:

splang.FunctionDeclaration(
    name="main",
    returns="bool",
    arguments={
        'myArgument': 'json<INPLACESCHEMA>'
    },
    schemas=[
        ("INPLACESCHEMA", {
            "field1": "str",
            "field2": "si32",
            "field3": "ui64",
        })
    ]
)

Provádí se pomocí tuple, první položka je název schématu, druhá je slovník s poli.

Správa paměti¤

Správa paměti v SP-Langu je založena na konceptu paměťových arén - memory arenas.

Diagram: Rozložení paměťových arén

Paměťová aréna je předem alokovaný větší kus paměti, který je k dispozici pro daný životní cyklus (tj. jeden cyklus zpracování události). Když nějaký kód související se zpracováním událostí potřebuje paměť, požádá o kousek z paměťové arény. Tento kousek je poskytnut rychle, protože je vždy odebrán ze začátku volného místa v aréně (tzv. offset). Rozdělení proběhne najednou pro celou arénu. Mluvíme o tzv. "resetu" paměťové arény. To znamená, že koncept paměťové arény je velmi efektivní, nezavádí fragmentaci paměti a dobře se kombinuje s konceptem statického jedinečného přiřazení SP-Langu.

Paměťová aréna také podporuje seznam destruktorů, který umožňuje integraci s tradičními např. malloc alokacemi pro technologie třetích stran, které nejsou kompatibilní s paměťovou arénou (např. knihovna PCRE2). Destruktory se provádějí při resetu arény.

Paměťová aréna může být rozšířena o další paměťový chunk, pokud je aktuální chunk vyčerpán.

Datové typy

Datové typy SP-Lang¤

V SP-Lang hraje typový systém klíčovou roli při zajišťování správnosti a efektivity vykonávání výrazů.
SP-Lang využívá odvozování typů.
To znamená, že typový systém funguje na pozadí, poskytuje vysoký výkon, aniž by zatěžoval uživatele svými složitostmi.
Tento přístup umožňuje bezproblémový a uživatelsky přívětivý zážitek, kde pokročilí uživatelé mohou přistupovat k typovému systému pro jemnější kontrolu a optimalizaci.

Info

Typový systém je soubor pravidel, která definují, jak jsou datové typy klasifikovány, kombinovány a manipulovány v jazyce.
Pomáhá odhalit potenciální chyby již na začátku, zlepšuje spolehlivost kódu a zajišťuje, že operace jsou prováděny pouze na kompatibilních datových typech.

Skalarové typy¤

Skalarové typy jsou základními stavebními kameny jazyka, které představují jednotlivé hodnoty.
Jsou nezbytné pro práci s různými druhy dat a provádění různých operací.

Celá čísla¤

Celá čísla jsou celá čísla, jako -5, 0 nebo 42, která mohou být použita pro počítání nebo jednoduché aritmetické operace.
Celá čísla mohou být podepsaná nebo nepodepsaná.

Typ	Název	Typ	Název	Bity	Byty
`si8`	Podepsané 8bitové celé číslo	`ui8`	Nepodepsané 8bitové celé číslo	8	1
`si16`	Podepsané 16bitové celé číslo	`ui16`	Nepodepsané 16bitové celé číslo	16	2
`si32`	Podepsané 32bitové celé číslo	`ui32`	Nepodepsané 32bitové celé číslo	32	4
`si64`	Podepsané 64bitové celé číslo	`ui64`	Nepodepsané 64bitové celé číslo	64	8
`si128`	Podepsané 128bitové celé číslo	`ui128`	Nepodepsané 128bitové celé číslo	128	16
`si256`	Podepsané 256bitové celé číslo	`ui256`	Nepodepsané 256bitové celé číslo	256	32

Preferovaný (výchozí) typ celého čísla je si64 (podepsané 64bitové celé číslo), následované ui64 (nepodepsané 64bitové celé číslo).
To je proto, že SP-Lang je navržen primárně pro 64bitové CPU.

int je alias pro si64.

Warning

256bitové velikosti zatím nejsou plně podporovány.

Booleovský¤

Booleovský (bool) je typ, který má jednu ze dvou možných hodnot označených jako True a False.

Čísla s plovoucí desetinnou čárkou¤

Čísla s plovoucí desetinnou čárkou jsou desetinná čísla, jako 3.14 nebo -0.5, která jsou užitečná pro výpočty zahrnující zlomky nebo přesnější hodnoty.

Typ	Název	Byty
`fp16`	16bitové float	2
`fp32`	32bitové float	4
`fp64`	64bitové float	8
`fp128`	128bitové float	16

Warning

fp16 a fp128 nejsou plně podporovány.

Warning

Alias float se překládá na fp64, což se překládá na LLVM double (odlišné od aliasu float).

Složené skalarové typy¤

Složené skalarové typy jsou navrženy pro hodnoty, které poskytují nějakou vnitřní strukturu (takže technicky jsou to záznamy nebo n-tice), ale mohou se vejít do skalarového typu (např. pro účely výkonu nebo optimalizace).

Datum/Čas¤

datetime

Toto je hodnota, která představuje datum a čas v UTC, pomocí rozbité struktury času.
Rozbitý čas znamená, že rok, měsíc, den, hodina, minuta, sekunda a mikrosekunda jsou uloženy v dedikovaných polích; odlišně od např. UNIX timestamp.

Časové pásmo: UTC
Rozlišení: mikrosekundy (šest desetinných míst)
64bitové nepodepsané celé číslo, aka ui64

Složky rozbitého času

y / rok
m / měsíc
d / den
H / hodina
M / minuta
S / sekunda
u / mikrosekunda

Podrobnější popis data/času je zde.

IP Adresa¤

Tento datový typ obsahuje adresu IPv4 nebo IPv6.

ip

Základní skalarový typ: ui128

RFC 4291

IPv4 jsou mapovány do IPv6 prostoru, jak je předepsáno v RFC 4291 "IPv4-Mapped IPv6 Address".
Například, IPv4 adresa 12.23.45.67 bude mapována do IPv6 adresy ::ffff:c17:2d43.

MAC Adresa¤

Tento datový typ obsahuje MAC adresu, (EUI-48).

Co je MAC adresa?

MAC adresa (zkratka pro medium access control address) je jedinečný identifikátor přiřazený síťové kartě atd.

mac

Základní skalarový typ: ui64, pouze 6 oktetů je použito v EUI-48.

Geografická souřadnice¤

Tento typ představuje geografickou souřadnici, konkrétně délku a šířku.

geopoint

Základní skalarový typ: u64

Podrobnější popis geopointu je zde.

Obecné typy¤

Obecné typy se používají v rané fázi analýzy, optimalizace a kompilace SP-Lang.
Doplnkový typ je Specifický typ.
SP-Lang převádí obecné typy na specifické typy pomocí mechanismu zvaného odvozování typů.
Pokud nelze obecný typ převést na specifický, kompilace selže a je potřeba poskytnout více informací pro odvozování typů.

Obecný typ začíná velkým T.
Také pokud typ kontejneru obsahuje obecný typ, typ kontejneru nebo strukturní typ sám je považován za obecný.

Typy kontejnerů¤

Seznam¤

[Ti]

Ti se odkazuje na typ položky v seznamu

Seznam musí obsahovat nula, jednu nebo více položek stejného typu.

Typový konstruktor je !LIST výraz.

Množina¤

{Ti}

Ti se odkazuje na typ položky v množině

Typový konstruktor je !SET výraz.

Slovník¤

{Tk:Tv}

Tk se odkazuje na typ klíče
Tv se odkazuje na typ hodnoty

Typový konstruktor je !DICT výraz.

Taška¤

[(Tk,Tv)]

Tk se odkazuje na typ klíče
Tv se odkazuje na typ hodnoty

Taška (aka multimap) je kontejner, který umožňuje duplicitní klíče, na rozdíl od slovníku, který umožňuje pouze jedinečné klíče.

Tip

Taška je v podstatě seznam 2-nic (párů).

Produktové typy¤

Produktový typ je složený typ, vytvořený kombinováním jiných typů do struktury.

N-tice¤

Podpis: (T1, T2, T3, ...)

Typový konstruktor je !TUPLE výraz.

Je ekvivalentní k strukturnímu typu v LLVM IR.

Tip

N-tice bez členů, respektive (), je unit.

Záznam¤

Podpis: (name1: T1, name2: T2, name3: T3, ...)

Typový konstruktor je !RECORD výraz.

Je ekvivalentní k C struct.

Součet typ¤

Součet typ je datová struktura používaná k uchování hodnoty, která může mít několik různých typů.

Jakýkoliv¤

any

Typ any je speciální typ, který představuje hodnotu, která může mít jakýkoliv typ.

Warning

Typ any by neměl být používán jako preferovaný typ, protože má dodatečné náklady.
Přesto je spíše užitečný pro typování slovníku, který kombinuje typy (např. {str:any}) a další situace, kde není typ hodnoty znám v době kompilace.

Hodnota obsažená v typu any je vždy umístěna v paměti (např. paměťovém poolu); z tohoto důvodu je tento typ pomalejší než ostatní, které preferují ukládání hodnot v registrech CPU.

Typ any je rekurzivní typ; může obsahovat sám sebe, protože obsahuje všechny ostatní typy v typovém vesmíru.
Z tohoto důvodu je nemožné vypočítat obecnou nebo dokonce maximální velikost proměnné any.

Typy objektů¤

Řetězec¤

str

Musí být v kódování UTF-8.

Note

str může být převeden na [ui8] (seznam ui8) bez ztráty; je to binární ekvivalent.

Byty¤

Práce v pokroku

Plánováno

Enum¤

Práce v pokroku

Plánováno

Regex¤

regex

Obsahuje zkompilovaný vzor pro regulární výraz.

Pokud je vzor regexu konstantní, pak je zkompilován během příslušné doby kompilace výrazu.
V případě dynamického vzoru regexu se kompilace regexu provádí během vyhodnocení výrazu.

JSON¤

json<SCHEMA>

JSON objekt, výsledek JSON analýzy.
Je to typ založený na schématu.

Typ funkce¤

Funkce¤

(arg1:T1,arg2:T2,arg3:T3)->Tr

T1, T2, T3 jsou typy vstupů funkcí arg1, arg2 a arg3 respektive.
Tr specifikuje výstupní typ funkce.

Pythonické typy¤

Pythonické typy jsou typy objektů, které poskytují rozhraní s Pythonem.

Python Slovník¤

pydict<SCHEMA>

Python slovník.
Je to typ založený na schématu.

Python Objekt¤

pyobj

Obecný Python objekt.

Python Seznam¤

pylist

Python seznam.

Python N-tice¤

pytuple

Přetypování¤

Použijte !CAST výraz pro změnu typu hodnoty.

!CAST
what: 1234
type: fp32

nebo ekvivalentní zkrácenou verzi:

!!fp32 1234

Note

Přetypování je také skvělým pomocníkem pro odvozování typů, což znamená, že může být použito k explicitnímu označení typu, pokud je to potřeba.

Typy založené na schématu¤

Schéma je koncept SP-Lang, jak propojit systémy bez schématu, jako je JSON nebo Python, s pevně typovaným SP-Lang.
Schéma je v podstatě adresář, který mapuje pole na jejich typy a tak dále.
Pro více informací pokračujte do kapitoly o SP-Lang schématech.

Typ založený na schématu SP-Lang specifikuje schéma pomocí názvu schématu: json<SCHEMANAME>.
Název schématu se používá k nalezení definice schématu např. v knihovně.

Seznam typů založených na schématu: * pydict<...> * json<...>

Vestavěná schémata¤

ANY: Toto schéma deklaruje, že jakýkoliv člen má být typu any.
VOID: Toto schéma nemá žádného člena, použijte definici typu na místě pro specifikaci typů polí.

SP-Lang datum/čas¤

Typ datetime je hodnota, která představuje datum a čas v UTC, pomocí rozložené časové struktury.
Rozložený čas znamená, že rok, měsíc, den, hodina, minuta, sekunda a mikrosekunda jsou uloženy v dedikovaných polích; odlišně od například UNIX timestampu.

Časové pásmo: UTC
Rozlišení: mikrosekundy (šest desetinných míst)

Užitečné nástroje

Bitové rozložení¤

Datetime je uložen v 64bitovém unsigned integer (ui64); little-endian formát, Intel/AMD 64bit nativní.

Pozice	Komponenta	Bitů	Maska	Typ*	Rozsah	Poznámka
58-63		4			0…15	OK (0)/Chyba (8)/Rezervováno
46-57	rok	14		`si16`	-8190…8191
42-45	měsíc	4	0x0F	`ui8`	1…12	Indexováno od 1
37-41	den	5	0x1F	`ui8`	1…31	Indexováno od 1
32-36	hodina	5	0x1F	`ui8`	0…24
26-31	minuta	6	0x3F	`ui8`	0…59
20-25	sekunda	6	0x3F	`ui8`	0…60	60 je pro přestupnou sekundu
0-19	mikrosekunda	20		`ui32`	0…1000000

Note

*) Typ je doporučený/minimální byte-aligned typ pro příslušnou komponentu.

Detaily časového pásma¤

Informace o časovém pásmu pochází z pytz respektive z IANA databáze časových pásem.

Note

Databáze časových pásem má přesnost až na minutu, což znamená, že sekundy a mikrosekundy zůstávají nedotčeny při převodu z/do UTC.

Data časového pásma jsou reprezentována strukturou adresářů v souborovém systému, která se obvykle nachází na /usr/share/splang nebo na místě určeném proměnnou prostředí SPLANG_SHARE_DIR.
Skutečná data časového pásma jsou uložena v podložce tzinfo.
Data časového pásma jsou generována skriptem generate_datetime_timezones.py během instalace SPLang.

Příklad složky tzinfo

```
.
└── tzinfo
  ├── Europe
    │  ├── Amsterdam.sptl
    │  ├── Amsterdam.sptb
    │  ├── Andorra.sptl
    │  ├── Andorra.sptb
```

.sptl a .sptb soubory obsahují rychlostně optimalizované binární tabulky, které podporují rychlé vyhledávání pro převody místního času <-> UTC.
.sptl je pro little-endian CPU architektury (x86 a x86-64), .sptb je pro big-endian architektury.

Soubor je memory-mapped do paměti procesu SP-Lang, zarovnaný na 64byte hranici, takže může být přímo použit jako vyhledávání.

Společné struktury¤

ym: Rok & měsíc, ym = (rok << 4) + měsíc
dhm: Den, hodina & minuta, dhm = (den << 11) + (hodina << 6) + minuta

Obě struktury jsou bitové části skalární hodnoty datetime a mohou být extrahovány z datetime pomocí AND a SHR.**

Hlavička souboru časového pásma¤

Délka hlavičky je 64 bytů.
Nespecifikované byty jsou nastaveny na 0 a rezervovány pro budoucí použití.

Pozice 00...03: SPt / magický identifikátor
Pozice 04: < pro little-endian CPU architekturu, > pro big-endian
Pozice 05: Verze (aktuálně 1 ASCII znak)
Pozice 08...09: Minimální rok/měsíc (min_ym) v tomto souboru, měsíc MUSÍ BÝT 1
Pozice 10...11: Maximální rok/měsíc (min_ym) v tomto souboru
Pozice 12...15: Pozice "parser tabulky" v souboru, vynásobené 64, typicky 1, protože parser tabulka je uložena přímo za hlavičkou

Parser tabulka časového pásma¤

Parser tabulka je vyhledávací tabulka používaná pro převod z místního data/času na UTC.

Tabulka je organizována do řádků/roků a sloupců/měsíců.
Buňka má šířku 4 byty (32bitů), řádek má tedy délku 64 bytů.

Prvních 12 buněk jsou "primární parser buňky" (světle modrá barva), číslo odráží číslo měsíce (1...12).
Zbývající 4 buňky jsou "parser next buňky", číslo nX je index.

Primární parser buňka¤

Pozice buňky pro dané datum/čas se vypočítává jako pos = (ym - min_ym) << 5, což znamená, že rok a měsíc jsou použity pro lokalizaci buňky, minus minimální hodnotu roku a měsíce pro tabulku.

Struktura buňky:

16 bitů: rozsah, 16bitů, dhm
3 bitů: next
7 bitů: hodinový offset od UTC
6 bitů: minutový offset od UTC

dhm označuje den, hodinu a minutu v roce/měsíci, kdy je pozorována změna času (např. začátek/konec letního času).
Pro typický měsíc - kde není pozorována žádná změna času - hodnota dhm představuje maximum v daném měsíci.

Pokud je dhm pro vstupní datum/čas matematicky nižší než dhm z primární buňky, pak jsou informace o hodině a minutě použity k úpravě data/času z místního na UTC.

Pokud je dhm větší, pak next obsahuje číslo "parser next buňky"; přítomné na konci příslušného řádku parser tabulky.

Parser next buňka¤

"Parser next buňka" obsahuje "pokračování" informací pro měsíc, kde je pozorována změna času.
"Pokračování" znamená offset od UTC, který nastává, když místní čas překročí hranici změny času.

Struktura buňky:

16 bitů: rozsah, 16bitů, dhm
3 bitů: nepoužité, nastaveno na 0
7 bitů: hodinový offset od UTC
6 bitů: minutový offset od UTC

dhm označuje den, hodinu a minutu v roce/měsíci, kdy je pozorována DALŠÍ změna času (např. začátek/konec letního času).
Protože v současnosti podporujeme pouze jednu změnu času v měsíci, je toto pole nastaveno na maximální dhm pro daný měsíc.

Informace o hodině a minutě jsou použity k úpravě data/času z místního na UTC.

Note

V současnosti je podporována pouze jedna změna času za měsíc, což se zdá být plně dostačující pro všechny informace v databázi časových pásem IANA.

Prázdné/nepoužité next buňky jsou nulovány.

Chyby¤

Pokud je bit 63 datetime nastaven, pak hodnota data/času představuje chybu.
Pravděpodobně výraz, který tuto hodnotu vytvořil, selhal nějakým způsobem.

Chybový kód je uložen v dolních 32 bitech.

Smíšené typy¤

Protože datetime je 64bitový unsigned integer, může se stát - ačkoliv to NENÍ doporučeno - že bude použit jiný formát reprezentace data/času.
Toto je tabulka, jak automaticky detekovat, jaký formát je použit pro reprezentaci data/času.

Reprezentace	1. ledna 2000	1. ledna 2100	Dolní rozsah	Horní rozsah
UNIX timestamp	946 681 200	4 102 441 200	0	10 000 000 000
UNIX timestamp (milli)	946 681 200 000	4 102 441 200 000	100 000 000 000	10 000 000 000 000
UNIX timestamp (micro)	946 681 200 000 000	4 102 441 200 000 000	100 000 000 000 000	10 000 000 000 000 000
SP-Lang datetime	140 742 023 840 793 010	147 778 898 258 559 000	100 000 000 000 000 000	-

SP-Lang geopoint¤

Typ geopoint je složený datový typ navržený k efektivnímu ukládání a reprezentaci geografických souřadnic, konkrétně délky a šířky, v kompaktním binárním formátu. Kombinuje délku a šířku do jednoho 64bitového celého čísla, přičemž využívá kódování s pevnou desetinnou čárkou, aby zajistilo přesnost a efektivní ukládání. Typ geopoint poskytuje rovnováhu mezi přesností a efektivitou ukládání, což z něj činí ideální volbu pro moderní architektury CPU s 64 bity.

Formát¤

Vyšších 32 bitů reprezentuje zakódovanou délku, a nižších 32 bitů reprezentuje zakódovanou šířku. Obě, délka i šířka, jsou zakódovány jako nepodsigned 32bitová celá čísla (ui32).

Délka¤

Měřítko pro délku je: (2^32 / 360) = ~11930464.711

Kódování: encoded_longitude = (longitude + 180) * (2^32 / 360)

Dekódování: longitude = (encoded_longitude / (2^32 / 360)) - 180

Šířka¤

Měřítko pro šířku je: (2^32 / 180) = ~23860929.422

Kódování: encoded_latitude = (latitude + 90) * (2^32 / 180)

Dekódování: latitude = (encoded_latitude / (2^32 / 180)) - 90

Přesnost¤

Zakódovaná délka má přesnost přibližně 4.76 metrů na rovníku.

Zakódovaná šířka má přesnost přibližně 1.19 metrů.

Řetězce¤

Řetězce v SP-Lang používají UTF-8 kódování. Reprezentace typu řetězce je str.

Reprezentace řetězce¤

Řetězec je reprezentován P-String odpovídajícím záznamu s následujícími položkami:

Délka řetězce v bajtech jako 64bitové nezáporné číslo.
Ukazatel na začátek dat řetězce.

Řetězec je také pole bajtů

Hodnota str je binárně kompatibilní s [ui8], seznamem ui8.

Kompatibilita s řetězci ukončenými NULL¤

Hodnota str NESMÍ končit s \0 (NULL).

Další \0 může být umístěno hned za daty řetězce, ale nesmí být zahrnuto do délky řetězce. To poskytuje přímou kompatibilitu se systémy řetězců ukončených NULL. Není však implicitně zaručeno str.

Řetězec ukončený NULL může být "převeden" na str vytvořením nového str pomocí strlen() a aktuálního ukazatele na data řetězce. Alternativně může být také vytvořena úplná kopie.

Data řetězce¤

Data řetězce jsou paměťový prostor, který obsahuje skutečnou hodnotu řetězce.

Data řetězce mohou být:

umístěna hned za strukturou str
zcela nezávislý vyrovnávací paměť řetězce (“pohled na řetězec”)

Data řetězce mohou být sdílena s mnoha strukturami str, včetně referencí na části dat řetězce (tj. podřetězce).

Podrobnosti o typech kontejnerů¤

Seznam¤

seznam představuje konečný počet uspořádaných položek, kde se stejná položka může objevit více než jednou.

Množina¤

množina je složení vnitřního seznamu a hash tabulky.

Slovník¤

slovník (také známý jako dictionary) je složení množiny (sama o sobě hash tabulka a seznam) klíčů (nazývaných Množina klíčů s Seznamem klíčů) a seznamu hodnot (nazývaných Seznam hodnot).

Hash tabulka¤

Typy Množina a Slovník používají hash tabulku.

hash tabulka je navržena tak, aby mapovala 64bitový hash klíče přímo na index položky. Strategie dokonalého hashe je aplikována, takže pro konstrukci hash tabulky není implementováno žádné řešení kolizí. Pokud algoritmus pro konstrukci hash tabulky detekuje kolizi, algoritmus se restartuje s jinou hodnotou semene. Tento přístup využívá relativně nízkou míru kolizí xxhash64.

Hash tabulka může být (lenivě) generována pouze tehdy, když je potřeba (např. pro výrazy !IN a !GET). To platí pro objekty vytvářené dynamicky během běhu programu. Statické množiny a slovníky poskytují připravenou hash tabulku.

Hash tabulka se vyhledává pomocí binárního vyhledávání.

Použité hashovací funkce jsou:

XXH3 64bit s hodnotou semene pro str
xor s hodnotou semene pro si64, si32, si16, si8, ui64, ui32, si16, ui8

Výrazy

SP-Lang Výrazy¤

Výrazy v SP-Lang jsou psány jako YAML tagové direktivy.

Seznam výrazů¤

Výraz	Typ	Kategorie	Popis
`!COUNT`	sekvence	agregace	Počítá počet položek.
`!MIN`	sekvence	agregace	Vypočítá minimum ze seznamu položek.
`!MAX`	sekvence	agregace	Vypočítá maximum ze seznamu položek.
`!AVG`	sekvence	agregace	Vypočítá průměr (aritmetický průměr) položek v seznamu.
`!MEDIAN`	sekvence	agregace	Najde medián (střední hodnotu) seznamu položek.
`!MODE`	sekvence	agregace	Najde hodnotu, která se objevuje nejčastěji.
`!RANGE`	sekvence	agregace	Najde rozdíl mezi nejvyšší a nejnižší hodnotou.
`!ADD`	sekvence	aritmetika	Sčítání.
`!SUB`	sekvence	aritmetika	Odečítání.
`!MUL`	sekvence	aritmetika	Násobení.
`!DIV`	sekvence	aritmetika	Dělení.
`!MOD`	sekvence	aritmetika	Modulo.
`!POW`	sekvence	aritmetika	Exponenciace.
`!ABS`	mapování	aritmetika	Absolutní hodnota.
`!SHL`	mapování	bitwise	Levý logický posun.
`!SHR`	mapování	bitwise	Pravý logický posun.
`!SAL`	mapování	bitwise	Levý aritmetický posun.
`!ROL`	mapování	bitwise	Kružnicová rotace vlevo.
`!ROR`	mapování	bitwise	Kružnicová rotace vpravo.
`!EQ`	sekvence	porovnání	Rovná se.
`!NE`	sekvence	porovnání	Není rovno.
`!LT`	sekvence	porovnání	Menší než.
`!LE`	sekvence	porovnání	Menší nebo rovno.
`!GT`	sekvence	porovnání	Větší než.
`!GE`	sekvence	porovnání	Větší nebo rovno.
`!IN`	mapování	porovnání	Test členství.
`!IF`	mapování	ovládání	Jednoduché podmínkové větvení.
`!WHEN`	sekvence	ovládání	Silné větvení.
`!MATCH`	mapování	ovládání	Shoda vzoru.
`!TRY`	sekvence	ovládání	Provádí až do prvního výrazu bez chyby.
`!MAP`	mapování	ovládání	Aplikuje výraz na každý prvek v sekvenci.
`!REDUCE`	mapování	ovládání	Sníží prvky seznamu na jednu hodnotu.
`!INCLUDE`	skalární	direktivy	Vloží obsah jiného souboru.
`!ARGUMENT`	skalární	funkce	Získá argument funkce.
`!ARG`	skalární	funkce	Získá argument funkce.
`!FUNCTION`	mapování	funkce	Definuje novou funkci.
`!FN`	mapování	funkce	Definuje novou funkci.
`!SELF`	mapování	funkce	Aplikuje aktuální funkci, používá se pro rekurzi.
`!IP.FORMAT`	mapování	ip	Převede IP adresu na řetězec.
`!IP.INSUBNET`	mapování	ip	Zkontroluje, zda IP adresa spadá do podsítě.
`!GET`	mapování	json	Získá jednu hodnotu z JSON.
`!JSON.PARSE`	mapování	json	Parsuje JSON.
`!LIST`	mapování	seznam	Vytváří seznam položek.
`!GET`	mapování	seznam	Získá jednu položku ze seznamu.
`!AND`	sekvence	logika	Konjunkce.
`!OR`	sekvence	logika	Disjunkce.
`!NOT`	sekvence	logika	Negace.
`!LOOKUP`	mapování	vyhledávání	Vytváří nové vyhledávání.
`!GET`	mapování	vyhledávání	Získá položky z vyhledávání.
`IN`	mapování	vyhledávání	Zkontroluje, zda je položka ve vyhledávání.
`!RECORD`	mapování	záznam	Kolekce pojmenovaných položek.
`!GET`	mapování	záznam	Získá položku ze záznamu.
`!REGEX`		regex	Vyhledávání pomocí regulárního výrazu.
`!REGEX.REPLACE`	mapování	regex	Nahrazení pomocí regulárního výrazu.
`!REGEX.SPLIT`	mapování	regex	Rozdělí řetězec podle regulárního výrazu.
`!REGEX.FINDALL`	mapování	regex	Najde všechny výskyty podle regulárního výrazu.
`!REGEX.PARSE`	mapování	regex	Parsuje podle regulárního výrazu.
`!SET`	mapování	množina	Množina položek.
`!IN`	mapování	množina	Test členství.
`!IN`	mapování	řetězec	Testuje, zda řetězec obsahuje podřetězec.
`!STARTSWITH`	mapování	řetězec	Testuje, zda řetězec začíná vybraným prefixem.
`!ENDSWITH`	mapování	řetězec	Testuje, zda řetězec končí vybraným sufixem.
`!SUBSTRING`	mapování	řetězec	Extrahuje část řetězce.
`!LOWER`	mapování	řetězec	Převádí řetězec na malá písmena.
`!UPPER`	mapování	řetězec	Převádí řetězec na velká písmena.
`!CUT`	mapování	řetězec	Ořízne řetězec a vrátí vybranou část.
`!SPLIT`	mapování	řetězec	Rozdělí řetězec na seznam.
`!RSPLIT`	mapování	řetězec	Rozdělí řetězec zprava na seznam.
`!JOIN`	mapování	řetězec	Spojí seznam řetězců.
`!TUPLE`	mapování	n-tice	Kolekce položek.
`!GET`	mapování	n-tice	Získá položku z n-tice.
`!CAST`	mapování	utility	Převede typ argumentu na jiný.
`!HASH`	mapování	utility	Vypočítá hash.
`!DEBUG`	mapování	utility	Ladí výraz.

Agregační výrazy¤

Agregační výraz je typ funkce, která provádí výpočty nad množinou hodnot a jako výsledek vrací jednu hodnotu. Tyto výrazy se běžně používají k shrnutí nebo zhuštění dat.

!COUNT: Počítá počet položek.
!MAX, !MIN: Vypočítává maximum / minimum.
!AVG: Vypočítává průměr (aritmetický průměr).
!MEDIAN: Najde prostřední hodnotu.
!MODE: Najde hodnotu, která se vyskytuje nejčastěji.
!RANGE: Najde rozdíl mezi nejvyšší a nejnižší hodnotou.

`!COUNT`¤

Spočítá počet položek v seznamu.

Typ: Sequence

Example

!COUNT
- Frodo Pytlík
- Samvěd Křepelka
- Gandalf
- Legolas
- Gimli
- Aragorn
- Boromir z Gondoru
- Smělmír Brandorád
- Pipin Bral

Vrací 9.

`!MAX`¤

Vrací maximální hodnotu z posloupnosti.

Typ: Sequence

Example

!MAX
- 1.5
- 2.6
- 5.1
- 3.05
- 4.45

Výsledek tohoto výrazu je 5.1.

`!MIN`¤

Vrací minimální hodnotu z posloupnosti.

Typ: Sequence

Example

!MIN
- 2.6
- 3.05
- 4.45
- 0.5
- 5.1

Výsledek tohoto výrazu je 0.5.

`!AVG`¤

Vypočítá aritmetický průměr.

Typ: Sequence

Info

Více informací o aritmetickém průměru na Wikipedii.

Example

!AVG
- 6
- 2
- 4

Výpočet průměru (6+2+4)/3, výsledek je 4.

`!MEDIAN`¤

Medián je prostřední hodnota v seznamu čísel; polovina hodnot je větší než medián a polovina je menší než medián. Pokud má seznam sudý počet prvků, je medián aritmetickým průměrem dvou prostředních hodnot.

Typ: Sequence

Info

Více informací o medián na Wikipedii.

Example

!MEDIAN
- 1
- 4
- -1
- 9
- 101

Vrací 4.

`!MODE`¤

Modus je označení pro hodnotu nebo hodnoty, které se v seznamu vyskytují nejčastěji. Lze ji použít k vyjádření centrální tendence souboru dat.

Typ: Sequence

Info

Více informací o mode na Wikipedii.

Example

!MODE
- 10
- 10
- -20
- -20
- 6
- 10

Vrací 10.

`!RANGE`¤

Vypočítává rozdíl mezi největší a nejmenší hodnotou.

Typ: Sequence

Info

Více informací o range na Wikipedii.

Example

!RANGE
- 1
- 3
- 4
- 20
- -1

Aritmetické výrazy¤

Přehled¤

Aritmetické výrazy se používají pro základní aritmetické operace s daty.

!ADD: Sčítání.
!SUB: Odčítání.
!MUL: Násobení.
!DIV: Dělení.
!MOD: Zbytek po dělení (modulo).
!POW: Exponentiation.
!ABS: Absolutní hodnota.

`!ADD`¤

Typ: Sequence

Můžete sčítat následující typy:

Čísla (celá čísla a desetinná čísla)
Řetězce
Seznamy
Množiny
Tuples
Records

Příklad

!ADD
- 4
- -5
- 6

Vypočítá 4+(-5)+6, výsledek je 5.

`!SUB`¤

Typ: Sequence

Příklad

!SUB
- 3
- 1
- -5

Vypočítá 3-1-(-5), výsledek je 7.

`!MUL`¤

Typ: Sequence

Příklad

!MUL
- 7
- 11
- 13

Vypočítá 7*11*13, výsledek je 1001 (což je shodou okolností Šahrazádino číslo).

`!DIV`¤

Typ: Sequence

Příklad

!DIV
- 21
- 1.5

Vypočítá 21/1.5, výsledek je 14.0.

Dělení nulou¤

Dělení nulou vede k chybě, která se může kaskádovitě projevit ve výrazu.

Pro řešení této situace lze použít výraz !TRY. První položkou výrazu !TRY je !DIV, který může způsobit chybu dělení nulou. Druhou položkou je hodnota, která bude vrácena, pokud k takové chybě dojde.

!TRY
- !DIV
  - !ARG input
  - 0.0
- 5.0

`!MOD`¤

Typ: Sequence

Vypočítá znaménkový zbytek dělení (neboli výsledek operace modulo).

Info

Více informací o operaci modulo na Wikipedii.

Příklad

!MOD
- 21
- 4

Vypočítá 21 mod 4, výsledek je 1.

Příklad

!MOD
- -10
- 3

Vypočítá -10 mod 3, výsledek je 2.

`!POW`¤

Typ: Sequence

Vypočítá exponent.

Příklad

!POW
- 2
- 8

Vypočítá 2^8, výsledek je 16.

`!ABS`¤

Typ: Mapping

!ABS
what: <x>

Vypočítá absolutní hodnotu vstupu x, což je nezáporná hodnota x bez ohledu na její znaménko.

Příklad

!ABS
what: -8.5

Výsledek je hodnota 8.5.

Bitové operace¤

Přehled¤

Bitové posuny zachází s hodnotou jako se sérií bitů, binární číslice hodnoty jsou posunuty doleva nebo doprava.

!SHL, !SHR: Logické posuny doleva a doprava.
!SAL, !SAR: Aritmetické posuny doleva a doprava.
!ROL, !ROR: Kruhové posuny doleva a doprava.

Existují také bitové výrazy !AND, !OR a !NOT, viz kapitolu Logické výrazy.

`!SHL`¤

Logický posun doleva.

Typ: Mapping.

!SHL
what: <...>
by: <...>

Tip

Levý posun lze použít jako rychlé násobení čísly 2, 4, 8 atd.

Příklad

!SHL
what: 9
by: 2

9 je reprezentována binární hodnotou 1001. Levý logický posun posune bity doleva o 2 pozice. Výsledkem je 100100, což je v desítkovém zápise 36. To je stejný výsledek jako 9 * (2^2).

`!SHR`¤

Logický posun doprava.

Typ: Mapping.

!SHR
what: <...>
by: <...>

Tip

Pravý posun lze použít jako rychlé dělení čísly 2, 4, 8 atd.

Příklad

!SHR
what: 16
by: 3

16 je reprezentovaná 10000. Logický posun posune bity doprava o 3. Výsledkem je 10, tedy 2 v desítkovém zápisu. To je stejný výsledek jako 16 / (2^3).

`!SAL`¤

Aritmetický posun doleva.

Typ: Mapping.

!SAL
what: <...>
by: <...>

Příklad

!SAL
what: 60
by: 2

`!SAR`¤

Pravý aritmetický posun.

Typ: Mapping.

!SAR
what: <...>
by: <...>

`!ROL`¤

Kruhový posun doleva.

Typ: Mapping.

!ROL
what: <...>
by: <...>

`!ROR`¤

Kruhový posun doprava.

Typ: Mapping.

!ROR
what: <...>
by: <...>

Porovnávací výrazy¤

Testovací výraz vyhodnotí vstupy a na základě výsledku testu vrátí logickou hodnotu true nebo false.

!EQ: Rovná se
!NE: Nerovná se
!LT: Menší než
!LE: Menší nebo rovno
!GT: Větší než
!GE: Větší nebo rovno
!IN: Test výskytu

`!EQ`¤

Rovná se.

Typ: Sekvence.

Example

!EQ
- !ARG count
- 3

Porovnává argument count s 3, vrací count == 3.

`!NE`¤

Nerovná se.

Typ: Sekvence.

Jedná se o zápornou obdobu !EQ.

Example

!NE
- !ARG name
- Frodo

Porovnává argument name s Frodo, vrací name != Frodo.

`!LT`¤

Menší než.

Typ: Sekvence.

Example

!LT
- !ARG count
- 5

Příklad testu count < 5.

`!LE`¤

Menší nebo rovno.

Typ: Sekvence.

Example

!LE
- 2
- !ARG count
- 5

Příklad testu rozsahu 2 <= count <= 5.

`!GT`¤

Větší než.

Typ: Sekvence.

Example

!GT [!ARG count, 5]

Příklad testu count > 5 pomocí kompaktní formy YAMLu.

`!GE`¤

Větší nebo rovno.

Typ: Sekvence.

Example

!GT
- !ARG count
- 5

Příklad testu count >= 5.

`!IN`¤

Test výskytu.

Typ: Mapování.

!IN
what: <...>
where: <...>

Výraz !IN se používá ke kontrole, zda hodnota what vyskytuje v hodnotě where, nebo ne. Hodnota where může být řetězec, kontejner (seznam, množina, slovník), strukturní typ atd. Vyhodnotí se na true, pokud najde hodnotu what v zadané hodnotě where, a na false v opačném případě.

Example

!IN
what: 5
where:
  - 1
  - 2
  - 3
  - 4
  - 5

Zkontroluje přítomnost hodnoty 5 v seznamu where. Vrátí true.

Example

!IN
what: "Willy"
where: "John Willy Boo"

Zkontroluje přítomnost podřetězce Willy v hodnotě John Willy Boo. Vrátí true.

Řídicí výrazy¤

Přehled¤

SP-Lang nabízí celou řadu řídicích výrazů.

!IF: Jednoduché podmíněné větvení.
!WHEN: Silné větvení.
!MATCH: Porovnávání vzorů.
!TRY: Provádění do prvního bezchybného výrazu.
!MAP: Aplikace výrazu na každý prvek v posloupnosti.
!REDUCE: Redukce prvků seznamu na jedinou hodnotu.

`!IF`¤

Jednoduché podmíněné větvení.

Typ: Mapping.

Výraz !IF je rozhodovací výraz, který vede vyhodnocení k rozhodování na základě zadaného testu.

!IF
test: <expression>
then: <expression>
else: <expression>

Na základě hodnoty test se vyhodnotí větev:

then v případě test !EQ true
else v případě test !EQ false

Oba případy then a else musejí vracet stejný typ, který bude zároveň typem návratové hodnoty !IF.

Example

!IF
test:
  !EQ
  - !ARG input
  - 2
then:
  Je to dva.
else:
  Není to dva.

`!WHEN`¤

Silné větvení.

Typ: Sequence.

Výraz !WHEN je podstatně silnější než výraz !IF. Jednotlivé případy mohou odpovídat mnoha různým vzorům, včetně intervalových shod, tuples atd.

!WHEN
- test: <expression>
  then: <expression>

- test: <expression>
  then: <expression>

- test: <expression>
  then: <expression>

- ...

- else: <expression>

Pokud není zadáno else, pak WHEN vrací False.

Example

Příklad použití !WHEN pro přesnou shodu, shodu rozsahu a nastavenou shodu:

!WHEN

# Přesná shoda hodnot
- test:
    !EQ
    - !ARG key
    - 34
  then:
    "třicet čtyři"

# Shoda rozsahu
- test:
    !LT
    - 40
    - !ARG key
    - 50
  then:
    "čtyřicet až padesát (bez krajních hodnot)"

# In-set match
- test:
    !IN
    what: !ARG key
    where:
      - 75
      - 77
      - 79
  then:
    "sedmdesát pět, sedm, devět"

- else:
    "neznámý"

`!MATCH`¤

Porovnávání vzorů.

Typ: Mapping.

!MATCH
what: <what-expression>
with:
  <value>: <expression>
  <value>: <expression>
  ...
else:
  <expression>

Výraz !MATCH vyhodnotí výraz what-expression, přiřadí hodnotu výrazu k klauzuli case a provede výraz expression spojený s tímto případem.

Větev else výrazu !MATCH je nepovinná. Výraz selže s chybou, pokud není nalezena žádná odpovídající <value> a větev else chybí.

Example

!MATCH
what: !ARG value
with:
    1: "jedna"
    2: "dva"
    3: "tři"
else:
    "jiné číslo"

Použití !MATCH pro strukturování kódu

!MATCH
what: !ARG kód
with:
    1: !INCLUDE code-1.yaml
    2: !INCLUDE code-2.yaml
else:
    !INCLUDE code-else.yaml

`!TRY`¤

Provádění do prvního bezchybného výrazu.

Typ: Sequence

!TRY
- <expression>
- <expression>
- <expression>
...

Iteruje jednotlivými výrazy (odshora dolů), pokud výraz vrátí nenulový výsledek (None), zastaví iteraci a vrátí tuto hodnotu. V opačném případě pokračuje k dalšímu výrazu.

Při dosažení konce seznamu vrátí None (chyba).

Poznámka: Zastaralý název tohoto výrazu byl !FIRST. Nepoužívá se od listopadu 2022.

`!MAP`¤

Použít výraz na každý prvek v posloupnosti.

Typ: Mapping.

!MAP
what: <sequence>
apply: <expression>

Výraz apply se aplikuje na každý prvek v posloupnosti what s argumentem x obsahujícím příslušnou hodnotu prvku. Výsledkem je nový seznam s transformovanými prvky.

Example

!MAP
what: [1, 2, 3, 4, 5, 6, 7]
apply:
    !ADD [!ARG x, 10]

Výsledek je [11, 12, 13, 14, 15, 16, 17].

`!REDUCE`¤

Redukce prvků seznamu na jedinou hodnotu.

Typ: Mapping.

!REDUCE
what: <expression>
apply: <expression>
initval: <expression>
fold: <left|right>

Výraz apply se aplikuje na každý prvek v posloupnosti what s argumentem a obsahujícím agregaci operace reduce a argumentem b obsahujícím příslušnou hodnotu prvku.

Výraz initval poskytuje počáteční hodnotu pro argument a.

Nepovinná hodnota fold určuje "levé skládání" (left, výchozí) nebo "pravé skládání" (right).

Example

!REDUCE
what: [1, 2, 3, 4, 5, 6, 7]
initval: -10
apply:
  !ADD [!ARG a, !ARG b]

Vypočítá součet posloupnosti s počáteční hodnotou -10.
Výsledek je 18 = -10 + 1 + 2 + 3 + 4 + 5 + 6 + 7.

Výrazy pro datum a čas¤

Přehled¤

Datum a čas se v SP-Langu vyjadřují pomocí typu datetime. Má mikrosekundové rozlišení a rozsah od roku 8190 př.n.l. do roku 8191. Je v časovém pásmu UTC.

Info

Další informace o typu datetime najdete zde.

!NOW: Aktuální datum a čas.
!DATETIME: Konstrukce nového datetime.
!DATETIME.FORMAT: Formátování datetime.
!GET: Získání komponenty datetime.

`!NOW`¤

Typ: Mapping.

Získá aktuální datum a čas.

!NOW

`!DATETIME`¤

Typ: Mapping.

Konstruuje datetime z komponent jako je rok, měsíc, den atd.

!DATETIME
year: <year>
month: <month>
day: <day>
hour: <hour>
minute: <minute>
second: <second>
microsecond: <microsecond>
timezone: <timezone>

year je celé číslo v rozsahu -8190 … 8191.
month je celé číslo v rozsahu 1 … 12.
day je celé číslo v rozsahu 1 … 31, odpovídající počtu dní v daném měsíci.
hour je celé číslo v rozsahu 0 … 24, je nepovinné a výchozí hodnota je 0.
minute je celé číslo v rozsahu 0 … 59, je nepovinné a výchozí hodnota je 0.
second je celé číslo v rozsahu 0 … 60, je nepovinné a výchozí hodnota je 0.
microsecond je celé číslo v rozsahu 0 … 1000000, je nepovinné a výchozí hodnota je 0.
timezone je název časového pásma podle IANA Time Zone Database. Je nepovinné a výchozí časové pásmo je UTC.

Příklad: Datum/čas v UTC

!DATETIME
year: 2021
month: 10
day: 13
hour: 12
minute: 34
second: 56
microsecond: 987654

Příklad: výchozí hodnoty

!DATETIME
year: 2021
month: 10
day: 13

Příklad: časová pásma

!DATETIME
year: 2021
month: 10
day: 13
timezone: Europe/Prague

!DATETIME
year: 2021
month: 10
day: 13
timezone: "+05:00"

`!DATETIME.FORMAT`¤

Typ: Mapping.

Formátuje informace o datu a čase na základě datetime.

!DATETIME.FORMAT
with: <datetime>
format: <format>
timezone: <string>

datetime obsahuje informace o datech a čase, které se mají použít pro formátování. format je řetězec, který obsahuje specifikaci formátu výstupu. timezone je nepovinná informace. Pokud je uvedena, bude čas vypsán v místním čase zadaném argumentem, jinak se použije časové pásmo UTC.

Formát¤

Direktiva	Komponenta
`%H`	Hodiny (24hodinové hodiny) jako desetinné číslo doplněné nulou.
`%M`	Minuta jako desetinné číslo doplněné nulou.
`%S`	Vteřina jako desetinné číslo doplněné nulou.
`%f`	Mikrosekunda jako desetinné číslo doplněné nulou na 6 číslic.
`%I`	Hodina (12hodinové hodiny) jako desetinné číslo doplněné nulou.
`%p`	Ekvivalent AM nebo PM v místním jazyce.
`%d`	Den v měsíci jako desetinné číslo doplněné nulou.
`%m`	Měsíc jako desetinné číslo doplněné nulou.
`%y`	Rok bez století jako desetinné číslo doplněné nulou.
`%Y`	Rok se stoletím jako desetinné číslo.
`%z`	Posun UTC.
`%a`	Zkrácený název dne v týdnu.
`%A`	Den v týdnu jako plný název.
`%w`	Den v týdnu jako desetinné číslo, kde 0 je neděle a 6 je sobota.
`%b`	Měsíc jako zkrácený název.
`%B`	Měsíc jako plný název.
`%j`	Den v roce jako desetinné číslo doplněné nulou.
`%U`	Číslo týdne v roce (neděle jako první den v týdnu) jako desetinné číslo doplněné nulou. Všechny dny v novém roce předcházející první neděli se považují za dny v týdnu 0.
`%W`	Číslo týdne v roce (pondělí jako první den v týdnu) jako desetinné číslo doplněné nulou. Všechny dny v novém roce předcházející prvnímu pondělí se považují za dny v týdnu 0.
`%c`	Reprezentace data a času.
`%x`	Reprezentace data.
`%X`	Reprezentace času.
`%%`	Doslovný znak '%'.

Example

!DATETIME.FORMAT
with: !NOW
format: "%Y-%m-%d %H:%M:%S"
timezone: "Europe/Prague"

Vypíše aktuální místní čas jako např. 2022-12-31 12:34:56 s použitím časového pásma "Europe/Prague".

`!DATETIME.PARSE`¤

Typ: Mapping.

Parsuje datum a čas z řetězce.

!DATETIME.PARSE
what: <string>
format: <format>
timezone: <timezone>

Vstupní řetězec what analyzuje pomocí řetězce format. Informace timezone je nepovinná. Pokud je uvedena, určuje místní časové pásmo řetězce what.

Další informace o řetězci format naleznete v kapitole Formát výše.

Example

!DATETIME.PARSE
what: "2021-06-29T16:51:43-08"
format: "%y-%m-%dT%H:%M:%S%z"

`!GET`¤

Typ: Mapping.

Extrahuje z datetime komponenty data/času, jako je hodina, minuta, den atd.

!GET
what: <string>
from: <datetime>
timezone: <timezone>

Vybere komponentu what z datetime. timezone je nepovinná, pokud není uvedena, použije se časová zóna UTC.

Komponenty¤

Direktiva	Komponenta
`year`, `y`	Rok
`month`, `m`	Měsíc
`day`, `d`	Den
`hour`, `H`	Hodina
`minute`, `M`	Minuta
`second`, `S`	Sekunda
`microsecond`, `f`	Mikrosekunda
`weekday`, `w`	Den v týdnu

Example

Získá komponentu hours aktuálního časového razítka s použitím časového pásma "Europe/Prague".

!GET
what: H
from: !NOW
timezone: "Europe/Prague"

Příklad: Aktuální rok

!GET { what: year, from: !NOW }

Slovníkové výrazy¤

Přehled¤

Slovník (dict) uchovává kolekci dvojic (klíč, hodnota) tak, že každý možný klíč se v kolekci vyskytuje nejvýše jednou. Klíče ve slovníku musí být stejného typu, stejně jako hodnoty.

Položka je dvojice (klíč, hodnota) reprezentovaná jako tuple.

Nápověda

Tuto strukturu můžete znát pod alternativními názvy "asociativní pole" nebo "mapa".

!DICT: Slovník.
!GET: Získat hodnotu ze slovníku.
!IN: Test výskytu.

`!DICT`¤

Slovník.

Typ: Mapping

!DICT
with:
  <key1>: <value1>
  <key2>: <value2>
  <key3>: <value3>
  ...

Nápověda

Pro zjištění počtu položek ve slovníku použijte !COUNT.

Příklad

V jazyce SP-Lang lze slovník zadat několika způsoby:

!DICT
with:
  key1: "One"
  key2: "Two"
  key3: "Three"

Implicitně zadaný slovník:

---
key1: "One"
key2: "Two"
key3: "Three"

Slovník zadaný zkráceně využívaje !!dict a flow stylu v YAML:

!!dict {key1: "One", key2: "Two", key3: "Three"}

Specifikace typu¤

Typ slovníku se označuje jako {Tk:Tv}, kde Tk je typ klíče a Tv je typ hodnoty. Další informace o typu slovníku naleznete v příslušné kapitole v typovém systému.

Slovník se pokusí odvodit svůj typ na základě přidaných položek. Typ první položky pravděpodobně poskytne typ klíče Tk a typ hodnoty Tv. Pokud je slovník prázdný, jeho odvozený typ je {str:si64}.

Toto lze přepsat pomocí explicitní specifikace typu:

!DICT
type: "{str:any}"
with:
  <key1>: <value1>
  <key2>: <value2>
  <key3>: <value3>
  ...

type je nepovinný argument obsahující řetězec se signaturou slovníku, která bude použita namísto odvozování typu z následníků.

Ve výše uvedeném příkladu je typ slovníku {str:any}, typ klíče je str a typ hodnot je any.

`!GET`¤

Získat hodnotu ze slovníku.

Typ: Mapping.

!GET
what: <key>
from: <dict>
default: <value>

Získá položku ze slovníku dict (slovník) identifikovaného pomocí key.

Pokud key není nalezen, vrátí default nebo chybu, pokud default není zadán. default je nepovinné.

Příklad

!GET
what: 3
from:
  !DICT
  with:
    1: "One"
    2: "Two"
    3: "Three"

Vrátí Three.

`!IN`¤

Test výskytu.

Typ: Mapping.

!IN
what: <key>
where: <dict>

Zkontroluje, zda je key přítomen v dict.

Poznámka

Výraz !IN je popsán v kapitole Porovnávací výrazy.

Příklad

!IN
what: 3
where:
  !DICT
  with:
    1: "One"
    2: "Two"
    3: "Three"

Direktivy¤

Přehled¤

Note

Direktivy SP-Lang jsou při kompilaci rozšířeny. Nejsou to výrazy.

!INCLUDE: Vloží obsah jiného souboru.

`!INCLUDE`¤

Vloží obsah jiného souboru.

Typ: Skalární, Direktiva.

Direktiva !INCLUDE slouží k vložení obsahu daného souboru do aktuálního souboru. Pokud není vkládaný soubor nalezen, SP-Lang zobrazí chybu.

Synopsis:

!INCLUDE <filename>

filename je název souboru v knihovně, který má být vložen.

Můžeme ho specifikovat pomocí:

absolutní cesty začínající na / z kořene knihovny,
relativní cesty k umístění souboru obsahujícího příkaz !INCLUDE

Přípona .yaml je nepovinná a bude přidána ke jménu souboru, pokud chybí.

Example

Toto je jednoduché začlenění souboru other_file.yaml:

!INCLUDE other_file.yaml

Example

V tomto příkladu se !INCLUDE používá k rozkladu většího výrazu na logicky oddělené soubory:

!MATCH
what: !GET {...}
with:
  'group1': !INCLUDE inc_group1
  'group2': !INCLUDE inc_group2

Výrazy pro funkce¤

Přehled¤

!ARGUMENT, !ARG: Získá argument funkce.
!FUNCTION, !FN: Definuje novou funkci.
!SELF: Aplikuje aktuální funkci, používá se pro rekurzi.

`!ARGUMENT`, `!ARG`¤

Umožňuje přístup k argumentu name.

Typ: Scalar.

Synopsis:

!ARGUMENT name

nebo

!ARG name

Tip

!ARG je zkrácená verze !ARGUMENT.

`!FUNCTION`, `!FN`¤

Výraz !FUNCTION definuje novou funkci. Obvykle se používá jako top-level expression.

Typ: Mapping.

Info

Výrazy SP-Lang jsou implicitně umístěné definice funkcí. To znamená, že ve většině případů lze !FUNCTION přeskočit a je uvedena pouze sekce do.

Synopsis:

!FUNCTION
name: <název funkce>
arguments:
  arg1: <typ>
  arg2: <typ>
  ...
returns: <typ>
schemas: <slovník schémat>
do:
  <výraz>

Tip

!FN je zkrácená verze !FUNCTION.

Example

!FUNCTION
arguments:
  a: si64
  b: si32
  c: si32
  d: si32
returns: fp64
do:
  !MUL
  - !ARGUMENT a
  - !ARGUMENT b
  - !ARGUMENT c
  - !ARGUMENT d

Tento výraz definuje funkci, která přijímá čtyři argumenty (a, b, c a d) s příslušnými datovými typy (si64, si32, si32 a si32) a vrací výsledek typu fp64. Funkce vynásobí čtyři vstupní argumenty (a, b, c a d) a vrátí součin jako číslo s desetinou čárkou (fp64).

`!SELF`¤

Příkaz !SELF umožňuje rekurzivně použít "self" alias aktuální funkci.

Typ: Mapping.

Synopsis:

!SELF
arg1: <hodnota>
arg2: <hodnota>
...

Note

Výraz !SELF je tzv. Y kombinátor.

Example

!FUNCTION
arguments: {x: int}
returns: int
do:
  !IF # hodnota <= 1
    test: !GT [!ARG x, 1]
    then: !MUL [!SELF {x: !SUB [!ARG x, 1]}, !ARG x]
   else: 1

Tento výraz definuje rekurzivní funkci, která přijímá jeden celočíselný argument x a vrací celočíselný výsledek. Funkce vypočítá faktoriál vstupního argumentu x pomocí příkazu if-else. Pokud je vstupní hodnota x větší než 1, funkce vynásobí x faktoriálem (x - 1), který vypočítá rekurzivním voláním sebe sama. Pokud je vstupní hodnota x menší nebo rovna 1, funkce vrátí 1.

Výrazy pro IP adresy¤

Přehled¤

IP adresy jsou interně reprezentovány jako 128bitová celá čísla bez znaménka. Takový typ může obsahovat jak IPv6, tak IPv4. IPv4 jsou mapovány do prostoru IPv6 pomocí RFC 4291 "IPv4-Mapped IPv6 Address".

!IP.FORMAT: Převádí IP adresu na řetězec.
!IP.INSUBNET: Zkontroluje, zda IP adresa spadá do podsítě.

`!IP.FORMAT`¤

Převádí IP adresu na řetězec.

Typ: Mapping.

Synopsis:

!IP.FORMAT
what: <ip>

Převádí vnitřní reprezentaci IP adresy na řetězec.

`!IP.INSUBNET`¤

Zkontroluje, zda IP adresa spadá do podsítě.

Typ: Mapping.

Synopsis:

!IP.INSUBNET
what: <ip>
subnet: <subnet>

!IP.INSUBNET
what: <ip>
subnet:
  - <string>
  - <string>
  - <string>

Testuje, zda what IP adresa patří do subnet nebo podsítí, vrací true, pokud ano, jinak false.

Příklad s jednou podsítí

!IP.INSUBNET
what: 192.168.1.1
subnet: 192.168.0.0/16

Příklad s více podsítěmi

!IP.INSUBNET
what: 1.2.3.4
subnet:
    - 10.0.0.0/8
    - 172.16.0.0/12
    - 192.168.0.0/16

Test, který kontroluje, zda adresa IP pochází z privátního adresního prostoru IPv4, jak je definováno v RFC 1918.

Kompaktní forma:

!IP.INSUBNET
what: 1.2.3.4
subnet: [10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16]

Parsování IP adresy¤

IP adresa je automaticky analyzována z řetězce. V případě potřeby můžete IP adresu z řetězce explicitně převést na typ ip:

!CAST
type: ip
what: 192.168.1.1

Parsování podsítě IP¤

IP podsíť je automaticky parsována z řetězce. V případě potřeby lze explicitně převést IP adresu z řetězce na typ ipsubnet:

!CAST
type: ipsubnet
what: 192.168.1.1/16

JSON¤

Přehled¤

SP-Lang nabízí vysokorychlostní přístup k datovým objektům JSON.

!GET: Získá jednotlivou hodnotu z JSON.
!JSON.PARSE: Parsuje JSON.

`!GET`¤

Získá jednotlivou hodnotu z JSON.

Typ: Mapping.

Synopsis:

!GET
what: <item>
typ: <type>
od: <json>
výchozí: <value>

Získat položku zadanou pomocí what z JSON objektu from. Pokud položka není nalezena, vrátí default nebo chybu, pokud není zadáno default. default je nepovinné.

Volitelně můžete zadat typ položky pomocí type.

Příklad

JSON (aka !ARG jsonmessage):

{
"foo.bar": "Příklad"
}

Pro získání pole foo.bar z výše uvedeného JSON:

!GET
what: foo.bar
from: !ARG jsonmessage

JSON Pointer¤

Pro přístup k položce ve vnořeném JSONu je třeba použít JSON Pointer (např. /foo/bar) jako what.

Pro odvození typu položky se použije schéma, ale pro složitější přístup doporučujeme použít argument type.

Vnořený JSON

Vnořený JSON (aka !ARG jsonmessage):

{
    "foo": {
        "bar": "Příklad"
        }
}

Příklad extrakce řetězce z vnořeného JSON:

!GET
what: /foo/bar
type: str
from: !ARG jsonmessage

`!JSON.PARSE`¤

Parsuje JSON.

Typ: Mapping.

Synopsis:

!JSON.PARSE
what: <str>
schéma: <schema>

Parsuje JSON řetězec. Výsledek lze použít např. pomocí operátoru !GET.

Nepovinný argument schema určuje schéma, které se má použít. Výchozím schématem je vestavěné ANY.

Příklad

!JSON.PARSE
what: |
{
    "string1": "Ahoj světe!",
    "string2": "Sbohem ..."
}

Výraz pro seznamy¤

Přehled¤

Seznam je jednou ze základních datových struktur, které SP-Lang poskytuje. Seznam obsahuje konečný počet uspořádaných položek, přičemž stejná položka se může vyskytovat vícekrát. Položky v seznamu musí být stejného typu.

Note

Seznam se někdy nepřesně nazývá také pole.

!LIST: Vytváří seznam položek.
!GET: Získá jednotlivou položku ze seznamu.

`!LIST`¤

Vytvoří seznam položek.

Typ: Implicitní sekvence, Mapování.

Synopsis:

!LIST
- ...
- ...

Hint

Použijte !COUNT pro určení počtu položek v seznamu.

Existuje několik způsobů, jak lze v jazyce SP-Lang zadat seznam:

Example

!LIST
- "One"
- "Two"
- "Three"
- "Four"
- "Five"

Example

Implicitní seznam pomocí sekvencí bloků YAML:

- "One"
- "Two"
- "Three"
- "Four"
- "Five"

Example

Implicitní seznam pomocí YAML flow sequences:

["One", "Two", "Three", "Four", "Five"]

Example

Formou mapování:

!LIST
with:
- "One"
- "Two"
- "Three"
- "Four"
- "Five"

`!GET`¤

Získá jednotlivou položku ze seznamu.

Typ: Mapování.

Synopsis:

!GET
what: <index položky v seznamu>
from: <seznam>

index je celé číslo (číslo). Může být záporné, v tom případě určuje položku od konce seznamu. Položky jsou indexovány od 0, to znamená, že první položka v seznamu má index 0.

Pokud je index mimo hranice seznamu, příkaz se vrátí s chybou.

Example

!GET
what: 3
from:
    !LIST
    - 1
    - 5
    - 30
    - 50
    - 80
    - 120

Vrací 50.

Example

!GET
what: -1
from:
    !LIST
    - 1
    - 5
    - 30
    - 50
    - 80
    - 120

Vrací poslední položku v seznamu, která je 120.

Logické výrazy¤

Přehled¤

Logické výrazy se běžně používají k vytváření přísnějších a přesnějších podmínek, jako je filtrování událostí nebo spouštění konkrétních akcí na základě souboru kritérií. Logické výrazy pracují s pravdivostními hodnotami true a false.

Logické výrazy jsou reprezentací logické algebry

Další informace naleznete na stránce boolean algebra na Wikipedii.

!AND: Konjunkce.
!OR: Disjunkce.
!NOT: Negace.

`!AND`¤

Logický výraz !AND se používá ke spojení dvou nebo více podmínek, které musí být všechny pravdivé, aby byl celý výraz pravdivý. Používá se k vytváření přísnějších a přesnějších podmínek.

Typ: Sequence

Synopsis:

!AND
- <condition 1>
- <condition 2>
- ...

V logickém výrazu !AND mohou být podmínky (condition 1, condition 2, ...) libovolné výrazy, které se vyhodnotí jako logická hodnota (true nebo false). Podmínky jsou vyhodnocovány shora dolů a proces vyhodnocování se zastaví, jakmile je nalezena nepravdivá podmínka, podle konceptu zkratového vyhodnocování.

Logická konjunkce

Další informace naleznete na stránce Logical conjunction na Wikipedii.

Example

!AND
- !EQ
    - !ARG vendor
    - TeskaLabs
- !EQ
    - !ARG product
    - LogMan.io
- !EQ
    - !ARG version
    - v23.10

V tomto příkladu, pokud se všechny podmínky vyhodnotí jako pravdivé, bude celý logický výraz !AND pravdivý. Pokud je některá z podmínek nepravdivá, bude logický výraz !AND nepravdivý.

Bitové `!AND`¤

Pokud se !AND použije na celočíselné typy místo na logické, vytvoří se bitové AND.

Example

!AND
- !ARG PRI
- 7

V tomto příkladu je argument PRI maskován číslem 7 (binárně 00000111).

`!OR`¤

Logický výraz !OR se používá ke spojení dvou nebo více podmínek, přičemž alespoň jedna z podmínek musí být pravdivá, aby byl celý výraz pravdivý. Používá se k vytváření flexibilnějších a komplexnějších podmínek.

Typ: Sequence

Synopsis:

!OR
- <condition 1>
- <condition 2>
- ...

Podmínky (condition 1, condition 2, ...) mohou být libovolné výrazy, které se vyhodnotí jako logická hodnota (true nebo false). Podmínky jsou vyhodnocovány shora dolů a proces vyhodnocování se zastaví, jakmile je nalezena pravdivá podmínka, podle konceptu zkráceného vyhodnocování.

Logická disjunkce

Další informace naleznete na stránce Logical disjunction na Wikipedii.

Example

!OR
- !EQ
    - !ARG description
    - neoprávněný přístup
- !EQ
    - !ARG reason
    - hrubá síla
- !EQ
    - !ARG message
    - Zjištěn malware

V tomto příkladu je výraz pravdivý, pokud je splněna některá z následujících podmínek:

Pole description odpovídá řetězci "unauthorized access".
Pole reason odpovídá řetězci "brute force".
Pole message odpovídá řetězci "malware detected".

Bitové `!OR`¤

Pokud se !OR použije na celočíselné typy místo na logické, poskytuje bitové OR.

Example

!OR
- 1  # Read access (binární 001, desítková 1)
- 4  # Execute access (binární 100, desítkově 4)

V tomto příkladu je výraz vyhodnocen jako 5.

Je to proto, že při bitové operaci !OR se každý odpovídající bit v binární reprezentaci obou čísel kombinuje pomocí výrazu !OR:

001 (přístup pro čtení)
100 (přístup pro spuštění)
---
101 (kombinovaná oprávnění)

Výraz vypočítá oprávnění s výslednou hodnotou (binární 101, desítková 5) z operace bitového OR, která kombinuje přístup ke čtení i ke spouštění.

`!NOT`¤

Logický výraz !NOT se používá k obrácení pravdivostní hodnoty podmínky. Používá se k vyloučení určitých podmínek, pokud nejsou splněny jiné podmínky.

Typ: Mapping.

Synopsis:

!NOT
what: <expression>

Negace

Další informace naleznete na stránce Negation na Wikipedii.

Bitové `!NOT`¤

Pokud je zadáno celé číslo, pak !NOT vrátí hodnotu s převrácenými bity what.

Tip

Pokud chcete otestovat, že celé číslo není nula, použijte testovací výraz !NE.

Vyhledávací výrazy¤

Přehled¤

!LOOKUP: Vytvoří nové vyhledávání.
!GET: Získá položky z vyhledávání.
IN: Zkontroluje, zda je položka ve vyhledávání.

`!LOOKUP`¤

Typ: Mapping.

`!GET`¤

Získá položku z vyhledávání.

Typ: Mapping.

`!IN`¤

Zkontroluje, zda je položka ve vyhledávání.

Typ: Mapping.

Výrazy pro záznam¤

Záznam (record) je jednou ze základních datových struktur poskytovaných SP-Langem. Jedná se o kolekci položek, které mohou mít různé typy. Položky záznamu jsou pojmenovány (na rozdíl od tuple) pomocí štítku (label).

Poznámka

Záznam je postaven na !TUPLE.

!RECORD: Kolekce pojmenovaných položek.
!GET: Získá položku ze záznamu.

`!RECORD`: Kolekce pojmenovaných položek¤

Typ: Mapping.

Synopsis:

!RECORD
with:
  item1: <item 1>
  item2: <item 2>
  ...

item1 a item2 jsou označení příslušných položek v záznamu.

Počet položek v záznamu není omezen. Pořadí položek je zachováno.

Příklad

!RECORD
with:
  jméno: John Doe
  věk: 37 let
  výška: 175,4

Příklad ve flow-formě:

!RECORD {with: {jméno: John Doe, věk: 37 let, výška: 175,4} }

Použití tagu !!record:

!!record {jméno: John Doe, věk: 37 let, výška: 175,4}

Vynucení konkrétního typu položky:

!RECORD
with:
  jméno: John Doe
  věk: !!ui8 37
  výška: 175,4

Pole age bude mít typ ui8.

`!GET`: Získá položku ze záznamu¤

Typ: Mapping.

Synopsis:

!GET
what: <name or index of the item>
from: <record>

Pokud je what řetězec, pak je to název pole v záznamu.

Pokud je what celé číslo, pak je to index v záznamu. Hodnota what může být záporná, v takovém případě určuje položku z konce seznamu. Položky jsou indexovány od 0, to znamená, že první položka v seznamu má index 0. Pokud je what mimo hranice seznamu, příkaz se vrátí s chybou.

Příklad použití názvů položek:

!GET
what: name
from:
  !RECORD
  with:
    jméno: John Doe
    věk: 32 let
    výška: 127,5

Vrátí John Doe.

Použití indexu položek:

!GET
what: 1
from:
  !RECORD
-  with:
    name: John Doe
    age: 32
    height: 127.5

Vrací 32, hodnotu položky age.

Použití záporného indexu položek:

!GET
what: -1
from:
  !RECORD
  with:
    name: John Doe
    age: 32
    height: 127.5

Vrací 127.5, hodnotu položky height.

Regexové výrazy¤

Přehled¤

Tip

Pomocí Regexr můžete vytvářet a testovat regulární výrazy.

!REGEX: Vyhledávání pomocí regulárního výrazu.
!REGEX.REPLACE: Nahrazení regulárním výrazem.
!REGEX.SPLIT: Rozdělení řetězce pomocí regulárního výrazu.
!REGEX.FINDALL: Najít všechny výskyty podle regulárního výrazu.
!REGEX.PARSE: Parsování pomocí regulárního výrazu.

`!REGEX`¤

Vyhledávání pomocí regulárního výrazu.

Typ: Mapping.

Synopsis:

!REGEX
what: <string>
regex: <regex>
hit: <hit>
miss: <miss>

Projde řetězec what a hledá libovolné místo, kde regulární výraz regex dává shodu. Pokud je shoda nalezena, vrátí se hit, jinak se vrátí miss.

Výraz hit je nepovinný, výchozí hodnota je true.

Výraz miss je nepovinný, výchozí hodnota je false.

Example

```yaml !IF test: !REGEX what: "Hello world!" regex: "world" then: "Ano :-)" else: "Ne ;-("

```

Jiná forma:

!REGEX
what: "Hello world!"
regex: "world"
hit: "Ano :-)"
miss: "Ne ;-("

`!REGEX.REPLACE`¤

Nahrazení regulárním výrazem.

Typ: Mapping.

Synopsis:

!REGEX.REPLACE
what: <string>
regex: <regex>
by: <string>

Nahradit regulární výraz regex odpovídající hodnotě what hodnotou by.

Example

!REGEX.REPLACE
what: "Hello world!"
regex: "world"
by: "Mars"

Vrací: Hello Mars!

`!REGEX.SPLIT`¤

Rozdělení řetězce pomocí regulárního výrazu.

Typ: Mapping.

Synopsis:

!REGEX.SPLIT
what: <string>
regex: <regex>
max: <integer>

Dělí řetězec what regulárním výrazem regex.

Nepovinný argument max určuje maximální počet rozdělení.

Example

!REGEX.SPLIT
what: "07/14/2007 12:34:56"
regex: "[/ :]"

Vrací: ['07', '14', '2007', '12', '34', '56']

`!REGEX.FINDALL`¤

Najít všechny výskyty podle regulárního výrazu.

Typ: Mapping.

Synopsis:

!REGEX.FINDALL
what: <string>
regex: <regex>

Najde všechny shody regex v řetězci what.

Example

!REGEX.FINDALL
what: "Frodo, Sam, Gandalf, Legolas, Gimli, Aragorn, Boromir, Smíšek, Pipin"
regex: \w+

Vrací: ['Frodo', 'Sam', 'Gandalf', 'Legolas', 'Gimli', 'Aragorn', 'Boromir', 'Smíšek', 'Pipin']

`!REGEX.PARSE`¤

Parsování pomocí regulárního výrazu.

Typ: Mapping.

Viz kapitolu !PARSE.REGEX

Výrazy pro práci s množinami¤

Přehled¤

Množina ukládá unikátní prvky, aniž by si všímala konkrétního pořadí. Prvky v množině musí být stejného typu. Množina je jednou ze základních datových struktur poskytovaných jazykem SP-Lang.

Množina je nejvhodnější pro testování přítomnosti hodnoty než pro získání konkrétního prvku z množiny.

!SET: Množina prvků.
!IN: Test členství.

`!SET`¤

Množina prvků.

Typ: Implicit sequence, Mapping.

Synopsis:

!SET
- ...
- ...

Hint

Použijte !COUNT pro určení počtu prvků v množině.

Existuje několik způsobů, jak lze v jazyce SP-Lang zadat množinu:

Example

!SET
- "One"
- "Dva"
- "Three"
- "Four"
- "Five"

Neuspořádaná množina

Neuspořádaná množina YAML:

!!set
? Žluté vepřové maso
? Růžová tráva
? Bílý sníh

YAML flow sequences

Kompaktní zápis množiny pomocí YAML flow sequences:

!SET ["One", "Dva", "Three", "Four", "Five"]

Example

Formulář pro mapování:

!SET
with:
- "One"
- "Dva"
- "Three"
- "Four"
- "Five"

`!IN`¤

Test členství.

Typ: Mapping.

Synopsis:

!IN
what: <item>
where: <set>

Zkontroluje, zda je item přítomna v set.

Výraz !IN je popsán v kapitole Porovnávací výrazy.

Example

!IN
what: 3
where:
  !SET
  with:
    - 1
    - 2
    - 5
    - 8

Výrazy pro řetězce¤

Přehled¤

!IN: Testuje, zda řetězec obsahuje podřetězec.
!STARTSWITH: Testuje, zda řetězec začíná vybranou předponou.
!ENDSWITH: Testuje, zda řetězec končí vybranou příponou.
!SUBSTRING: Extrahuje část řetězce.
!LOWER, !UPPER: Převádí řetězec na malá / velká písmena.
!CUT: Vyjme část řetězce a vrátí vybranou část.
!SPLIT, !RSPLIT: Rozdělí řetězec na seznam.
!JOIN: Spojí seznam řetězců.

`!IN`¤

Výraz !IN slouží ke kontrole, zda řetězec what je podřetězcem where, nebo ne.

Typ: Mapping.

Synopsis:

!IN
what: <...>
where: <...>

Pokud najde podřetězec what v řetězci where, vyhodnotí se jako true, v opačném případě jako false.

Example

!IN
what: "Willy"
where: "John Willy Boo"

Zkontroluje přítomnost podřetězce "Willy" v hodnotě where. Vrátí hodnotu true.

Varianta pro více řetězců¤

Existuje speciální varianta operátoru !IN pro kontrolu, zda je některý z řetězců uvedených v hodnotě what (v tomto případě seznam) v řetězci. Jedná se o efektivní, optimalizovanou implementaci víceřetězcového matcheru.

!IN
what:
  - "John"
  - "Boo"
  - "ly"
where: "John Willy Boo"

Jedná se o velmi efektivní způsob kontroly, zda je v řetězci where přítomen alespoň jeden podřetězec. Podporuje Incremental String Matching algoritmus pro rychlé porovnávání vzorů v řetězcích. Díky tomu je ideálním nástrojem pro komplexní filtrování jako samostatný bit nebo jako optimalizační technika.

Příklad optimalizace !REGEX pomocí víceřetězcového !IN:

    !AND
    - !IN
      where: !ARG message
      what:
      - "msgbox"
      - "showmod"
      - "showhelp"
      - "prompt"
      - "write"
      - "test"
      - "mail.com"
    - !REGEX
      what: !ARG message
      regex: "(msgbox|showmod(?:al|eless)dialog|showhelp|prompt|write)|(test[0-9])|([a-z]@mail\.com)

Tento přístup se doporučuje z aplikací v proudech, kde je třeba filtrovat rozsáhlé množství dat s předpokladem, že pouze menší část dat odpovídá vzorům. Přímá aplikace výrazu !REGEX výrazně zpomalí zpracování, protože se jedná o složitý regulární výraz. Jde o to "předfiltrovat" data jednodušší, ale rychlejší podmínkou tak, aby se k drahému !REGEX dostal jen zlomek dat. Typické zlepšení výkonu je 5x-10x.

Z tohoto důvodu musí být !IN dokonalou nadmnožinou !REGEX, to znamená:

!IN -> true, !REGEX -> true: true
!IN -> true, !REGEX -> false: false (to by měla být menšina případů)
!IN -> false, !REGEX -> false: false (předfiltrování, mělo by se jednat o většinu případů)
!IN -> false, !REGEX -> true: této kombinaci se MUSÍTE vyhnout, podle toho přijměte !IN a/nebo !REGEX.

`!STARTSWITH`¤

Vrací hodnotu true, pokud řetězec what začíná předponou prefix.

Typ: Mapping

Synopsis:

!STARTSWITH
what: <...>
prefix: <...>

Example

!STARTSWITH
what: "FooBar"
prefix: "Foo"

Víceřetězcová varianta¤

Práce v pokroku

Zatím neimplementováno.

!STARTSWITH
what: <...>
prefix: [<prefix1>, <prefix2>, ...]

Ve víceřetězcové variantě je definován seznam řetězců. Výraz se vyhodnotí jako true, pokud alespoň jeden prefixový řetězec odpovídá začátku řetězce what.

`!ENDSWITH`¤

Vrací hodnotu true, pokud řetězec what končí příponou postfix.

Typ: Mapping

Synopsis:

!ENDSWITH
what: <...>
postfix: <...>

Example

!ENDSWITH
what: "autoexec.bat"
postfix: ".bat"

Víceřetězcová varianta¤

Práce v pokroku

Zatím neimplementováno.

!ENDSWITH
what: <...>
postfix: [<postfix1>, <postfix2>, ...]

Ve víceřetězcové variantě je definován seznam řetězců. Výraz se vyhodnotí jako true, pokud alespoň jeden postfixový řetězec odpovídá konci řetězce what.

`!SUBSTRING`¤

Vrátí část řetězce what mezi indexy from a to.

Typ: Mapping

Synopsis:

!SUBSTRING
what: <...>
from: <...>
to: <...>

Info

První znak řetězce se nachází na pozici from=0.

Example

!SUBSTRING
what: "FooBar"
from: 1
to: 3

Vrací oo.

`!LOWER`¤

Převede řetězec nebo seznam řetězců na malá písmena.

Typ: Mapping

Synopsis:

!LOWER
what: <...>

Example

!LOWER
what: "FooBar"

Vrací foobar.

Example

!LOWER
what: ["FooBar", "Baz"]

Vrací seznam hodnot ["foobar", "baz"].

`!UPPER`¤

Typ: Mapping

Synopsis:

!UPPER
what: <...>

Example

!UPPER
what: "FooBar"

Vrací FOOBAR.

`!CUT`¤

Rozdělí řetězec oddělovačem a vrátí část identifikovanou indexem field (začíná 0).

Typ: Mapping

Synopsis:

!CUT
what: <string>
delimiter: <string>
field: <int>

Řetězec argumentu value bude rozdělen pomocí argumentu delimiter. Argument field určuje počet rozdělených řetězců, které se mají vrátit, počínaje 0.
Pokud je uveden záporný údaj field, pak se pole bere od konce řetězce, například -2 znamená předposlední podřetězec.

Example

!CUT
what: "Apple,Orange,Melon,Citrus,Pear"
delimiter: ","
field: 2

Vrátí hodnotu "Melon".

Example

!CUT
what: "Apple,Orange,Melon,Citrus,Pear"
delimiter: ","
field: -2

Vrátí hodnotu "Citrus".

`!SPLIT`¤

Rozdělí řetězec na seznam řetězců.

Typ: Mapping

Synopsis:

!SPLIT
what: <string>
delimiter: <string>
maxsplit: <number>

Řetězec argumentu what bude rozdělen pomocí argumentu delimiter. Nepovinný argument maxsplit určuje, kolik rozdělení se má provést.

Example

!SPLIT
what: "hello,world"
delimiter: ","

Výsledkem je seznam: ["hello", "world"].

`!RSPLIT`¤

Rozdělí řetězec zprava (od konce řetězce) do seznamu řetězců.

Typ: Mapping

Synopsis:

!RSPLIT
what: <string>
delimiter: <string>
maxsplit: <number>

Řetězec argumentu what bude rozdělen pomocí argumentu delimiter. Nepovinný argument maxsplit určuje, kolik rozdělení se má provést.

`!JOIN`¤

Typ: Mapping

Synopsis:

!JOIN
items:
  - <...>
  - <...>
delimiter: <string>
miss: ""

Výchozí delimiter je mezera (" ").

Pokud je položka None, použije se hodnota parametru miss, ve výchozím nastavení je to prázdný řetězec. Pokud je miss None a některá z položek items je None, výsledkem celého spojení je None.

Example

!JOIN
items:
  - "Foo"
  - "Bar"
delimiter: ","

Výrazy pro tuple¤

Přehled¤

Tuple (do češtiny přeložitelné asi jako 'pevný seznam') je jednou ze základních datových struktur, které SP-Lang nabízí. Tuple je kolekce položek, které mohou mít různé typy.

!TUPLE: Kolekce položek.
!GET: Získá položku z tuple.

`!TUPLE`¤

Kolekce položek.

Typ: Mapping.

Synopsis:

!TUPLE
with:
  - ...
  - ...
  ...

Počet položek v tuple není omezen. Pořadí položek je zachováno.

Příklad

!TUPLE
with:
  - John Doe
  - 37
  - 175.4

Příklad

Použití zápisu !!tuple:

!!tuple
- 1
- a
- 1.2

Příklad

Ještě stručnější verze !!tuple s použitím flow syntaxe:

!!tuple ['John Doe', 37, 175.4]

Příklad

Vynucení specifického typu položky:

!TUPLE
with:
  - John Doe
  - !!ui8 37
  - 175.4

Položka #1 bude mít typ ui8.

`!GET`¤

Získá položku z tuple.

Typ: Mapping.

Synopsis:

!GET
what: <index of the item>
from: <tuple>

Argument what je celé číslo (číslo), které představuje index v tuple. Může být záporné, v takovém případě určuje položku od konce seznamu.

Položky jsou indexovány od 0, to znamená, že první položka v seznamu má index 0.

Pokud je what mimo hranice seznamu, příkaz se vrátí s chybou.

Příklad

!GET
what: 1
from:
  !TUPLE
  with:
    - John Doe
    - 32
    - 127.5

Vrací 32.

Příklad

Použití záporného indexu položek:

!GET
what: -1
from:
  !TUPLE
  with:
    - John Doe
    - 32
    - 127.5

Vrací 127,5.

Pomocné výrazy¤

Přehled¤

!CAST: Převádí typ argumentu na jiný.
!HASH: Vypočítá digest.
!DEBUG: Ladí výraz.

`!CAST`¤

Převádí typ argumentu na jiný.

Typ: Mapping.

Synopsis:

!CAST
what: <input>
typ: <type>

Explicitně převádí typ what na typ type.

SP-Lang automaticky převádí typy argumentů, takže uživatel nemusí na typy vůbec myslet. Tato funkce se nazývá implicit casting.

V případě potřeby explicitní konverze typu použijte výraz !CAST. Jedná se o velmi mocnou metodu, která dělá hodně těžkou práci.

Další podrobnosti najdete v kapitole o typech.

Příklad

!CAST
what: "10.3"
type: fp64

Jedná se o explicitní převod řetězce na číslo s desetinnou čárkou.

`!HASH`¤

Vypočítá digest.

Typ: Mapping.

Synopsis:

!HASH
what: <input>
seed: <integer>
typ: <type of hash>

Vypočítá hash pro hodnotu what.

seed určuje počáteční hash seed.

type určuje hašovací funkci, výchozí hodnota je XXH64.

Podporované hašovací funkce¤

XXH64: xxHash, 64bitový, nekryptografický, extrémně rychlý hashovací algoritmus.
XXH3: xxHash, 64bit, nekryptografický, optimalizovaný pro malé vstupy

Více informací o xxHash naleznete na adrese xxhash.com.

Příklad

!HASH
what: "Hello world!"
seed: 5

`!DEBUG`¤

Vypíše obsah vstupu a na výstupu předá nezměněnou hodnotu.

Typ: Mapping.

Parsec

PARSEC výrazy¤

Skupina Parsec výrazů představuje koncept parser combinator.

Poskytují způsob, jak kombinovat základní parsery za účelem konstrukce složitějších parserů pro specifická pravidla. V tomto kontextu parser je funkce, která přijímá jediný řetězec jako vstup a produkuje strukturovaný výstup, který indikuje úspěšné zpracování nebo poskytuje chybovou zprávu, pokud proces zpracování selže.

Parsec výrazy jsou rozděleny do dvou skupin: parsery a kombinátory.

Parsers mohou být považovány za základní jednotky nebo stavební bloky. Jsou odpovědné za rozpoznávání a zpracování specifických vzorců nebo prvků v rámci vstupního řetězce.

Combinators jsou operátory (funkce vyššího řádu), které umožňují kombinaci a skládání parserů.

Každý výraz začíná prefixem !PARSE.

Výrazy pro analýzu¤

Přehled¤

Výrazy pro analýzu jsou funkce pro analýzu určité sekvence znaků.

Základní analyzátory mohou rozlišovat mezi číslicemi, písmeny a mezerami:

!PARSE.DIGIT, !PARSE.DIGITS: Analyzovat jednotlivé nebo více číslic.
!PARSE.LETTER, !PARSE.LETTERS: Analyzovat jednotlivá nebo více písmen.
!PARSE.SPACE, !PARSE.SPACES: Analyzovat jednotlivé nebo více znaků pro mezeru.
!PARSE.CHAR, !PARSE.CHARS: Analyzovat jednotlivé nebo více znaků.

Následující výrazy se používají pro analýzu znaků z vlastního souboru znaků a hledání specifických znaků v vstupních řetězcích:

!PARSE.EXACTLY: Analyzovat pouze specifickou sekvenci znaků.
!PARSE.UNTIL: Analyzovat do doby, než je nalezen specifický znak.
!PARSE.BETWEEN: Analyzovat mezi dvěma znaky.
!PARSE.ONEOF: Analyzovat pouze jeden z povolených znaků.
!PARSE.NONEOF: Analyzovat každý znak kromě zakázaných.
!PARSE.REGEX: Analyzovat znaky odpovídající regulárnímu výrazu.

Následující výrazy se používají pro analýzu dat a časů v různých formátech:

!PARSE.DATETIME: Analyzovat datum a čas.
!PARSE.MONTH: Analyzovat měsíc v různých formátech.
!PARSE.FRAC: Analyzovat desetinná čísla (což je užitečné pro analýzu mikrosekund).

Následující výrazy se používají pro analýzu specifických typů řetězců:

!PARSE.IP: Analyzovat IP adresu.
!PARSE.MAC: Analyzovat MAC adresu.

`!PARSE.DIGIT`¤

Analyzovat jednu číslici.

Typ: Analyzátor.

Synopse:

!PARSE.DIGIT

Example

Vstupní řetězec: 2

!PARSE.DIGIT

`!PARSE.DIGITS`¤

Analyzovat sekvenci číslic.

Typ: Analyzátor.

Synopse:

!PARSE.DIGITS
min: <...>
max: <...>
exactly: <...>

exactly určuje přesný počet číslic k analýze.
min a max určují minimální a maximální počet číslic k analýze. Nemohou být kombinovány s parametrem exactly.
Pokud není uvedeno žádné z polí min, max a exactly, analyzuje se co nejvíce číslic.

Warning

Pole exactly nelze použít společně s poli min nebo max. A samozřejmě hodnota max nemůže být menší než hodnota min.

Example

Vstupní řetězec: 123

!PARSE.DIGITS
max: 4

Více příkladů

Analyzovat co nejvíce číslic:

!PARSE.DIGITS

Analyzovat přesně 3 číslice:

!PARSE.DIGITS
exactly: 3

Analyzovat alespoň 2 číslice, ale ne více než 4:

!PARSE.DIGITS
min: 2
max: 4

`!PARSE.LETTER`¤

Analyzovat jedno písmeno.

Pod písmeny máme na mysli latinská písmena od A do Z, jak velká, tak malá.

Typ: Analyzátor.

Synopse:

!PARSE.LETTER

Example

Vstupní řetězec: A

!PARSE.LETTER

`!PARSE.LETTERS`¤

Analyzovat sekvenci písmen.

Pod písmeny máme na mysli latinská písmena od A do Z, jak velká, tak malá.

Typ: Analyzátor.

Synopse:

!PARSE.LETTERS
min: <...>
max: <...>
exactly: <...>

Pole min, max a exactly jsou volitelná.

Warning

Pole exactly nelze použít společně s poli min nebo max. A samozřejmě hodnota max nemůže být menší než hodnota min.

Example

Vstupní řetězec: cat

!PARSE.LETTERS
max: 4

Více příkladů

Analyzovat co nejvíce písmen:

!PARSE.LETTERS

Analyzovat přesně 3 písmena:

!PARSE.LETTERS
exactly: 3

Analyzovat alespoň 2 písmena, ale ne více než 4:

!PARSE.LETTERS
min: 2
max: 4

`!PARSE.SPACE`¤

Analyzovat jeden znak pro mezeru.

Typ: Analyzátor.

Synopse:

!PARSE.SPACE

`!PARSE.SPACES`¤

Analyzovat sekvenci znaků pro mezeru.

Analyzovat co nejvíce znaků pro mezeru:

Typ: Analyzátor.

Synopse:

!PARSE.SPACES

`!PARSE.CHAR`¤

Analyzovat jeden znak jakéhokoli typu.

Typ: Analyzátor.

Synopse:

!PARSE.CHAR

Example

Vstupní řetězec: @

!PARSE.CHAR

`!PARSE.CHARS`¤

Analyzovat sekvenci znaků.

Typ: Analyzátor.

Synopse:

!PARSE.CHARS
min: <...>
max: <...>
exactly: <...>

Pole min, max a exactly jsou volitelná.

Warning

Pole exactly nelze použít společně s poli min nebo max. A samozřejmě hodnota max nemůže být menší než hodnota min.

Example

Vstupní řetězec:_ name@123_

!PARSE.CHARS
max: 8

Tip

Použijte !PARSE.CHARS s výchozími nastaveními pro analýzu až do konce řetězce.

Více příkladů

Analyzovat co nejvíce znaků:

!PARSE.CHARS

Analyzovat přesně 3 znaky:

!PARSE.CHARS
exactly: 3

Analyzovat alespoň 2 znaky, ale ne více než 4:

!PARSE.CHARS
min: 2
max: 4

`!PARSE.EXACTLY`¤

Analyzovat přesně definovanou sekvenci znaků.

Typ: Analyzátor.

Synopse:

!PARSE.EXACTLY
what: <...>

nebo kratší verze:

!PARSE.EXACTLY <...>

Example

Vstupní řetězec:_Hello world!

!PARSE.EXACTLY
what: "Hello"

`!PARSE.UNTIL`¤

Analyzovat sekvenci znaků, dokud není nalezen specifický znak.

Typ: Analyzátor.

Synopse:

!PARSE.UNTIL
what: <...>
stop: <before/after>
eof: <true/false>

nebo kratší verze:

!PARSE.UNTIL <...>

what: Určuje jeden (a pouze jeden) znak, který se má hledat v vstupním řetězci.
stop: Určuje, zda by měl být zastavovací znak analyzován nebo ne. Možné hodnoty: before nebo after (výchozí).
eof: Určuje, zda bychom měli analyzovat až do konce řetězce, pokud symbol what není nalezen. Možné hodnoty: true nebo false (výchozí).
escape: Určuje únikový znak.

Info

Pole what musí být jediný znak. Ale některé znaky pro mezeru mohou být také použity, jako například tab. Pro hledání sekvence znaků viz výraz !PARSE.CHARS.LOOKAHEAD.

Example

Vstupní řetězec: 60290:11

!PARSE.UNTIL
what: ":"

Více příkladů

Analyzovat do : symbolu a zastavit se před ním:

!PARSE.UNTIL
what: ":"
stop: "before"

Analyzovat do symbolu mezery a zastavit se po něm:

!PARSE.UNTIL ' '

Analyzovat do , symbolu nebo analyzovat až do konce řetězce, pokud není nalezen:

!PARSE.UNTIL
what: ","
eof: true

Analyzovat do tab symbolu:

!PARSE.UNTIL
what: 'tab'

Analyzovat do svislé čáry, uniknout interní svislé čáry:
Vstupní řetězec:CRED_REFR\|success\|fail|

!PARSE.UNTIL
what: '|'
escape: '\'

`!PARSE.BETWEEN`¤

Analyzovat sekvenci znaků mezi dvěma specifickými znaky.

Typ: Analyzátor.

Synopse:

!PARSE.BETWEEN
what: <...>
start: <...>
stop: <...>
escape: <...>

nebo kratší verze:

!PARSE.BETWEEN <...>

what - určuje mezi kterými stejnými znaky bychom měli analyzovat.
start, stop - určuje mezi kterými různými znaky bychom měli analyzovat.
escape - určuje únikový znak.

Example

Vstupní řetězec:_ [10/May/2023:08:15:54 +0000]

!PARSE.BETWEEN
start: '['
stop: ']'

Více příkladů

Analyzovat mezi dvojitými uvozovkami:

!PARSE.BETWEEN
what: '"'

Analyzovat mezi dvojitými uvozovkami, krátká forma:

!PARSE.BETWEEN '"'

Analyzovat mezi dvojitými uvozovkami, uniknout interním dvojitým uvozovkám:
Vstupní řetězec:"one, \"two\", three"

!PARSE.BETWEEN
what: '"'
escape: '\'

`!PARSE.ONEOF`¤

Analyzovat jeden znak z vybraného souboru znaků.

Typ: Analyzátor.

Synopse:

!PARSE.ONEOF
what: <...>

nebo kratší verze:

!PARSE.ONEOF <...>

Example

Vstupní řetězce:

process finished with status 0
process finished with status 1
process finished with status x

!PARSE.KVLIST
- "process finished with status "
- !PARSE.ONEOF
what: "01x"

`!PARSE.NONEOF`¤

Analyzovat jeden znak, který není ve vybraném souboru znaků.

Typ: Analyzátor.

Synopse:

!PARSE.NONEOF
what: <...>

nebo kratší verze:

!PARSE.NONEOF <...>

Example

Vstupní řetězec:_ Wow!

!PARSE.NONEOF
what: ",;:[]()"

`!PARSE.REGEX`¤

Analyzovat sekvenci znaků, která odpovídá regulárnímu výrazu.

Typ: Analyzátor.

Synopse:

!PARSE.REGEX
what: <...>

Example

Vstupní řetězec:_ FTVW23_L-C: Message...

Výstup: FTVW23_L-C

!PARSE.REGEX
what: '[a-zA-Z0-9_\-0]+'

`!PARSE.DATETIME`¤

Analyzovat datum a čas.

Typ: Analyzátor.

Synopse:

!PARSE.DATETIME
- year: <...>
- month: <...>
- day: <...>
- hour: <...>
- minute: <...>
- second: <...>
- microsecond: <...>
- nanosecond: <...>
- timezone: <...>

Pole month a day jsou povinná.
Pole year je volitelné. Pokud není uvedeno, bude použita funkce smart year. Podporovány jsou jak 2, tak 4-místná čísla.
Pole hour, minute, second, microsecond, nanosecond jsou volitelná. Pokud nejsou uvedena, bude použita výchozí hodnota 0.
Uvedení pole mikrosekund jako microseconds? umožňuje analyzovat mikrosekundy nebo ne, v závislosti na jejich přítomnosti ve vstupním řetězci.
Pole timezone je volitelné. Pokud není uvedeno, bude použita výchozí hodnota UTC. Přečtěte si více o analýze časových pásem zde.

Běžné formáty datumu a času

Použijte Zkratky pro analýzu formátů datumu a času RFC 3339, RFC 3164 a ISO 8601.

UNIX čas

Pro analýzu datumu a času v UNIX čase použijte !PARSE.DATETIME EPOCH.

Tip

Použijte !PARSE.MONTH pro analýzu měsíce.

Tip

Použijte !PARSE.FRAC pro analýzu mikrosekund a nanosekund. Všimněte si, že tento výraz spotřebovává . a , také. Nezpracovávejte je odděleně.

Example

Vstupní řetězec: 2022-10-13T12:34:56.987654

!PARSE.DATETIME
- year: !PARSE.DIGITS
- '-'
- month: !PARSE.MONTH 'number'
- '-'
- day: !PARSE.DIGITS
- 'T'
- hour: !PARSE.DIGITS
- ':'
- minute: !PARSE.DIGITS
- ':'
- second: !PARSE.DIGITS
- microsecond: !PARSE.FRAC
        base: "micro"

Dvou-místný rok

Analyzovat datum a čas s dvou-místným rokem:

Vstupní řetězec: `22-10-13T12:34:

Kombinátorové výrazy¤

Přehled¤

Kombinátory jsou funkce pro skládání parsec výrazů (parserů nebo jiných kombinátorů) dohromady. Specifikují, jak se provádí analýza, jaký je typ výstupu. Mohou být použity pro řízení toku analýzy (aplikaci podmínkových nebo opakovaných výrazů) a také pro hledání předběžného výrazu ve vstupním řetězci.

Výběr výstupu určuje typ výstupu:

!PARSE.KVLIST: Analyzuje sekvenci klíčů a hodnot do typu tašky.
!PARSE.KV: Analyzuje klíč a hodnotu ze vstupního řetězce.
!PARSE.TUPLE: Analyzuje do typu n-tice.
!PARSE.RECORD

Výrazy pro řízení toku mohou provádět sekvenci parserových výrazů na základě určitých podmínek:

!PARSE.REPEAT: Provádí stejnou sekvenci výrazů vícekrát, podobně jako příkaz "for" z různých jazyků.
!PARSE.SEPARATED
!PARSE.OPTIONAL: Přidává volitelnou parserovou funkci, podobně jako příkaz "if/else" z různých jazyků.
!PARSE.TRIE: Provádí sekvenci výrazů na základě předpony vstupního řetězce.

Předběžné výrazy:

!PARSE.CHARS.LOOKAHEAD: Analyzuje, dokud není nalezena určitá sekvence znaků ve řetězci.

`!PARSE.KVLIST`¤

Analyzuje seznam párů klíč-hodnota.

Iterováním přes seznam prvků výraz !PARSE.KVLIST shromažďuje páry klíč-hodnota do tašky.

Typ: Kombinátor

Synopse:

!PARSE.KVLIST
- <...>
- key: <...>

Prvky, které nejsou klíčem, jsou analyzovány, ale nejsou shromažďovány:

!PARSE.KVLIST
- <...>  # analyzováno, ale ne shromážděno
- key1: <...>  # analyzováno a shromážděno
- key2: <...>  # analyzováno a shromážděno

Vnořené výrazy !PARSE.KVLIST jsou spojeny s nadřazeným:

!PARSE.KVLIST
- <...>
- !PARSE.KVLIST  # výraz je spojen s nadřazeným
  - key3: <...>
  - <...>
- key4: <...>

Example

Vstupní řetězec:

<141>May  9 10:00:00 myhost.com notice tmm1[22731]: User 'user' was logged in.

!PARSE.KVLIST
- '<'
- PRI: !PARSE.DIGITS
- '>'
- TIMESTAMP: !PARSE.DATETIME
                - month: !PARSE.MONTH 'short'
                - !PARSE.SPACES
                - day: !PARSE.DIGITS # Den
                - !PARSE.SPACES
                - hour: !PARSE.DIGITS # Hodiny
                - ':'
                - minute: !PARSE.DIGITS # Minuty
                - ':'
                - second: !PARSE.DIGITS # Sekundy

- !PARSE.SPACES
- HOSTNAME: !PARSE.UNTIL ' '
- LEVEL: !PARSE.UNTIL ' '
- PROCESS.NAME: !PARSE.UNTIL '['
- PROCESS.PID: !PARSE.DIGITS
- ']:'
- !PARSE.SPACES
- MESSAGE: !PARSE.CHARS

Výstup:

[
    (PRI, 141),
    (TIMESTAMP, 140994182325993472),
    (HOSTNAME, myhost.com),
    (LEVEL, notice),
    (PROCESS.NAME, tmm1),
    (PROCESS.PID, 22731),
    (MESSAGE, User 'user' was logged in.)
]

`!PARSE.KV`¤

Analyzuje klíč a hodnotu ze řetězce do páru klíč-hodnota, s možností přidání určité předpony.

Typ: Kombinátor

Synopse:

!PARSE.KV
- prefix: <...>
- key: <...>
- value: <...>
- <...> # volitelné prvky

prefix je volitelný. Pokud je specifikován, předpona bude přidána k key.
key a value jsou povinné.

Tip

Použijte kombinaci !PARSE.REPEAT a !PARSE.KV pro analýzu opakovaných párů klíč-hodnota. (viz příklady)

Example

Vstupní řetězec: eventID= "1011"

!PARSE.KV
- key: !PARSE.UNTIL '='
- !PARSE.SPACE
- value: !PARSE.BETWEEN {what: '"'}

Výstup: (eventID, 1011)

Analyzovat klíč a hodnotu se specifikovanou předponou

Vstupní řetězec: eventID= "1011"

!PARSE.KV
- key: !PARSE.UNTIL {what: '='}
prefix: SD.PARAM.
- !PARSE.SPACE
- value: !PARSE.BETWEEN {what: '"'}

Výstup: (SD.PARAM.eventID, 1011)

Použití spolu s !PARSE.REPEAT

Vstupní řetězec: devid="FEVM020000191439" vd="root" itime=1665629867

!PARSE.REPEAT
what: !PARSE.KV
    - !PARSE.OPTIONAL
    what: !PARSE.SPACE
    - key: !PARSE.UNTIL '='
    - value: !TRY
            - !PARSE.BETWEEN '"'
            - !PARSE.UNTIL { what: ' ', eof: true}

Výstup:

[
    (devid, FEVM020000191439),
    (vd, root),
    (itime, 1665629867)
]

`!PARSE.TUPLE`¤

Typ: Kombinátor

Analyzuje seznam hodnot do n-tice.

Iterováním přes seznam prvků výraz !PARSE.TUPLE shromažďuje hodnoty do n-tice.

Synopse:

!PARSE.TUPLE
- <...>
- <...>
- <...>

Example

Vstupní řetězec:_Ahoj světe!

!PARSE.TUPLE
- 'Ahoj'
- !PARSE.SPACE
- 'světe'
- '!'

Výstup: ('Ahoj', ' ', 'světe', '!')

`!PARSE.RECORD`¤

Analyzuje seznam hodnot do struktury záznamu.

Iterováním přes seznam prvků výraz !PARSE.RECORD shromažďuje hodnoty do struktury záznamu.

Typ: Kombinátor

Synopse:

!PARSE.RECORD
- <...>
- element1: <...>
- element2: <...>
- <...>

Example

Vstupní řetězec: <165>1

!PARSE.RECORD
- '<'
- severity: !PARSE.DIGITS
- '>'
- version: !PARSE.DIGITS
- ' '

Výstup: {'output.severity': 165, 'output.version': 1}

`!PARSE.REPEAT`¤

Analyzuje opakovaný vzor.

Typ: Kombinátor.

Synopse:

!PARSE.REPEAT
what: <výraz>
min: <...>
max: <...>
exactly: <...>

Pokud není specifikováno ani min, max, exactly, bude what opakováno co nejvíce.
exactly určuje přesný počet opakování.
min a max nastavují minimální a maximální počet opakování.

Example

Vstupní řetězec:_ host:myhost;ip:192.0.0.1;user:root;

!PARSE.KVLIST
- !PARSE.REPEAT
what: !PARSE.KV
    - key: !PARSE.UNTIL ':'
    - value: !PARSE.UNTIL ';'

To opakuje výraz !PARSE.KV co nejvíce.

Výstup:

[
    (host, myhost),
    (ip, 192.0.0.1),
    (user, root)
]

Analyzovat

Vstupní řetězec:_ ahoj ahoj ahoj Anna!

!PARSE.KVLIST
- !PARSE.REPEAT
    what: !PARSE.EXACTLY 'ahoj '
    exactly: 3
- NAME: !PARSE.UNTIL '!'

Výstup: [(NAME, Anna)]

Analyzovat

Vstupní řetězce:

ahoj ahoj Anna!
ahoj ahoj ahoj Anna!
ahoj ahoj ahoj ahoj Anna!

!PARSE.KVLIST
- !PARSE.REPEAT
    what: !PARSE.EXACTLY 'ahoj '
    min: 2
    max: 4
- NAME: !PARSE.UNTIL '!'

Výstup: [(NAME, Anna)]

`!PARSE.SEPARATED`¤

Analyzuje sekvenci s oddělovačem.

Typ: Kombinátor.

Synopse:

!PARSE.SEPARATED
what: <...>
sep: <...>
min: <...>
max: <...>
end: <...>

min a max jsou volitelné.
end určuje, zda je požadován koncový oddělovač. Ve výchozím nastavení je volitelný.

Example

Vstupní řetězec: 0->1->2->3

!PARSE.SEPARATED
what: !PARSE.DIGITS
sep: !PARSE.EXACTLY {what: "->"}
min: 3

Výstup: [0, 1, 2, 3]

Poznámka: koncový oddělovač je volitelný, takže vstupní řetězec 0->1->2->3-> je také platný.

Více příkladů

Analyzovat what hodnoty oddělené sep v [min;max] intervalu, koncový oddělovač je požadován:
Vstupní řetězec: 11,22,33,44,55,66,

!PARSE.SEPARATED
what: !PARSE.DIGITS
sep: !PARSE.EXACTLY {what: ","}
end: True
min: 3
max: 7

Analyzovat what hodnoty oddělené sep v [min;max] intervalu, koncový oddělovač není přítomen:
Vstupní řetězec: 0..1..2..3

!PARSE.SEPARATED
what: !PARSE.DIGITS
sep: !PARSE.EXACTLY {what: ".."}
end: False
min: 3
max: 5

`!PARSE.OPTIONAL`¤

Analyzuje volitelný vzor.

Typ: Kombinátor

Výraz !PARSE.OPTIONAL se pokouší analyzovat vstupní řetězec pomocí specifikovaného parseru. Pokud parser selže, počáteční pozice se vrátí na počáteční.

Synopse:

!PARSE.OPTIONAL
what: <...>

nebo kratší verze:

!PARSE.OPTIONAL <...>

Example

Vstupní řetězce:

mymachine myproc[10]: DHCPACK to
mymachine myproc[10]DHCPACK to

!PARSE.KVLIST
- HOSTNAME: !PARSE.UNTIL ' ' # mymachine
- TAG: !PARSE.UNTIL '[' # myproc
- PID: !PARSE.DIGITS  # 10
- !PARSE.EXACTLY ']'

# Analýza volitelných znaků
- !PARSE.OPTIONAL ':'
- !PARSE.OPTIONAL
    what: !PARSE.SPACE

- NAME: !PARSE.UNTIL ' '

`!PARSE.TRIE`¤

Typ: Kombinátor.

Analyzuje pomocí počáteční předpony.

Výraz !PARSE.TRIE vybírá jednu ze specifikovaných předpon a analyzuje zbytek vstupního řetězce pomocí odpovídajícího parseru. Pokud je specifikována prázdná předpona, bude použit odpovídající parser, pokud nejsou shodnuty jiné předpony.

Synopse:

!PARSE.TRIE
- <prefix1>: <...>
- <prefix2>: <...>
...

Tip

Použijte !PARSE.TRIE pro analýzu multivariačních logových zpráv.

Example

Vstupní řetězce:

Přijato odpojení z 10.17.248.1 port 60290:11: odpojeno uživatelem
Odpojeno od uživatele root 10.17.248.1 port 60290

!PARSE.TRIE
- 'Přijato odpojení z ': !PARSE.KVLIST
                            - CLIENT_IP: !PARSE.UNTIL ' '
                            - 'port '
                            - CLIENT_PORT: !PARSE.DIGITS
                            - ':'
                            - !PARSE.CHARS
- 'Odpojeno od uživatele ': !PARSE.KVLIST
                            - USERNAME: !PARSE.UNTIL ' '
                            - CLIENT_IP: !PARSE.UNTIL ' '
                            - 'port '
                            - CLIENT_PORT: !PARSE.DIGITS

Specifikujte

Vstupní řetězec:Selhalo přihlášení pro root z 218.92.0.190

!PARSE.TRIE
- 'Přijato odpojení z ': !PARSE.KVLIST
                            - CLIENT_IP: !PARSE.UNTIL ' '
                            - 'port '
                            - CLIENT_PORT: !PARSE.DIGITS
                            - ':'
                            - !PARSE.CHARS
- 'Odpojeno od uživatele ': !PARSE.KVLIST
                            - USERNAME: !PARSE.UNTIL ' '
                            - CLIENT_IP: !PARSE.UNTIL ' '
                            - 'port '
                            - CLIENT_PORT: !PARSE.DIGITS
- '': !PARSE.KVLIST
    - tags: ["trie-match-fail"]

Výstup: [(tags, ["trie-match-fail"])]

`!PARSE.CHARS.LOOKAHEAD`¤

Analyzuje znaky s použitím skupiny předběžného výrazu.

Analyzuje znaky, dokud není nalezena specifikovaná skupina předběžného výrazu, a zastaví se před ní.

Typ: _K

Vizuální programování

Vizuální programování v SP-Lang¤

SP-Lang umožňuje uživatelům vytvářet výrazy manipulací s prvky výrazu graficky, místo aby je specifikovali textově.

Příklad parseru Syslog implementovaného ve vizuálním SP-Lang:

Úvod

Dokumentace SP-Langu¤

Úvod¤

Vlastnosti jazyka SP-Lang¤

Věnování¤

Tutoriál k SP-Langu¤

Úvod¤

Hello World¤

SP-Lang je založen na YAMLu¤

Komentáře¤

Výrazy SP-Lang¤

Mapovací výrazy¤

Skládání výrazů¤

Argumenty¤

Závěr¤

Syntaxe jazyka SP¤

Komentáře¤

Čísla¤

Celá čísla¤

Desetinná čísla¤

Řetězce¤

Pravdivostní hodnoty (booleans)¤

Výrazy¤

Mapovací výrazy¤

Sekvenční výrazy¤

Skalární výrazy¤

Kotvy a aliasy¤

Struktura souboru SP-Lang¤

Jazyk

Design jazyka SP-Lang¤

Vlastnosti¤

📜 Deklarativní¤

🔗 Funkční¤

🔀 Bezstavový¤

🔐 Silně typovaný¤

💡 Podpora odvozování typů¤

🎓 Turingovsky úplný¤

Výkon jazyka SP-Lang¤

Úvod¤

Porovnávání více řetězců¤

Parsování JSON¤

Parsování IETF Syslogu¤

Referenční hardware¤

HW-M1-20¤

HW-I7-15¤

Schéma¤

Definice schématu¤

Možnosti¤

Možnost type¤

Možnost aliases¤

Možnost unit¤

Deklarace funkce (Python)¤

In-place schémata¤

Správa paměti¤

Datové typy

Datové typy SP-Lang¤

Skalarové typy¤

Celá čísla¤

Booleovský¤

Čísla s plovoucí desetinnou čárkou¤

Složené skalarové typy¤

Datum/Čas¤

IP Adresa¤

MAC Adresa¤

Geografická souřadnice¤

Obecné typy¤

Typy kontejnerů¤

Seznam¤

Množina¤

Slovník¤

Taška¤

Produktové typy¤

N-tice¤

Záznam¤

Součet typ¤

Jakýkoliv¤

Typy objektů¤

Řetězec¤

Byty¤

Enum¤

Možnost `type`¤

Možnost `aliases`¤

Možnost `unit`¤

`!COUNT`¤

`!MAX`¤

`!MIN`¤

`!AVG`¤

`!MEDIAN`¤

`!MODE`¤

`!RANGE`¤

`!ADD`¤

`!SUB`¤

`!MUL`¤

`!DIV`¤

`!MOD`¤

`!POW`¤

`!ABS`¤

`!SHL`¤

`!SHR`¤

`!SAL`¤

`!SAR`¤

`!ROL`¤

`!ROR`¤

`!EQ`¤

`!NE`¤

`!LT`¤