Table of Contents
Ú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
- "!"
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:
---
# 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¤
- 📜 Deklarativní jazyk
- 🔗 Funkční jazyk
- 🔀 Bezstavový jazyk
- 🔐 Silně typovaný jazyk
- 💡 Odvozování typů
- Syntaxe je založena na YAMLu
Kompilace anebo interpretace
SP-Lang je:
📜 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"
- 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íčeTv
se odkazuje na typ hodnoty
Typový konstruktor je !DICT
výraz.
Taška¤
[(Tk,Tv)]
Tk
se odkazuje na typ klíčeTv
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
aarg3
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 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 typuany
.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, typicky1
, 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 UTC6
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 07
bitů: hodinový offset od UTC6
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 prosi64
,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éhodatetime
.!DATETIME.FORMAT
: Formátovánídatetime
.!GET
: Získání komponentydatetime
.
!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 je0
.minute
je celé číslo v rozsahu 0 … 59, je nepovinné a výchozí hodnota je0
.second
je celé číslo v rozsahu 0 … 60, je nepovinné a výchozí hodnota je0
.microsecond
je celé číslo v rozsahu 0 … 1000000, je nepovinné a výchozí hodnota je0
.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.
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
¤
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
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
¤
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¤
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ů.
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
!!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.
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ý.
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
amax
určují minimální a maximální počet číslic k analýze. Nemohou být kombinovány s parametremexactly
.- Pokud není uvedeno žádné z polí
min
,max
aexactly
, 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
!PARSE.DIGITS
exactly: 3
!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
!PARSE.LETTERS
exactly: 3
!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
!PARSE.CHARS
exactly: 3
!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
neboafter
(výchozí). -
eof
: Určuje, zda bychom měli analyzovat až do konce řetězce, pokud symbolwhat
není nalezen. Možné hodnoty:true
nebofalse
(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"
!PARSE.UNTIL ' '
,
symbolu nebo analyzovat až do konce řetězce, pokud není nalezen:
!PARSE.UNTIL
what: ","
eof: true
tab
symbolu:
!PARSE.UNTIL
what: 'tab'
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: '"'
!PARSE.BETWEEN '"'
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: <...>
!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
aday
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í hodnotaUTC
. 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 kkey
.key
avalue
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: '"'}
(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
, budewhat
opakováno co nejvíce. exactly
určuje přesný počet opakování.min
amax
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
amax
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ů
Analyzovatwhat
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
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ě.
Ve výstavbě
Vizuální programování v SP-Lang je ve výstavbě.
Příklad parseru Syslog implementovaného ve vizuálním SP-Lang: