====== Standard-Units Übersicht ======
Stand: 2026-06-17 · Verzeichnis: ''std/''
Die Standardbibliothek von Lyx umfasst **356 Units** in 37 Kategorien. Sie folgt dem Prinzip **Zero-External-Dependencies**: Jede Unit ist entweder vollständig in Lyx implementiert oder wrappet direkt POSIX-Syscalls – ohne weitere Laufzeitbibliotheken als Pflichtabhängigkeit. Ausnahmen (OpenSSL, libssh2, mpg123, ALSA, Qt5) sind explizit dokumentiert und optional.
^ Kategorie ^ Units ^ Typischer Einsatz ^
| I/O & Dateisystem | 15 | Speicher, mmap, Fehlerbehandlung, I/O, Signale, Scheduling, Threads, Prozesse, xattr |
| Datenstrukturen | 4 | Listen, Vektoren, Hash-Tabellen, Sortieren |
| Strings & Kodierung | 10 | Suchen, Ersetzen, JSON, XML, YAML, Regex, URLs |
| Mathematik & Wissenschaft | 12 | Geometrie, Statistik, SIMD, GPS, Farben |
| KI & Maschinelles Lernen | 3 | Regression, Clustering, FastText |
| Kryptografie | 18 | AES, HMAC-SHA256, SHA-256, ECDSA, sichere Zufallszahlen, MD5, SHA-1, X25519, SHA-3/SHAKE; PQC: ML-KEM, ML-DSA, SLH-DSA, Hybrid-KEM, DADQ |
| System & Kernel | 7 | io_uring, IPC, BPF, ptrace/perf, Namespaces, Capabilities, sysadmin |
| Terminal & UI | 3 | ANSI-Farben, Raw-Input, X11 |
| Qt5-Bindings | 5 | Desktop-GUI, OpenGL, EGL |
| LyxVision (TUI-Framework) | 20 | Terminal-UI, Widgets, Dialoge |
| Netzwerk & Protokolle | 28 | HTTP, DNS, SMTP, MQTT, BGP, QUIC, DHCP, ARP, epoll, REST-Client |
| Datenbanken | 5 | MySQL, PostgreSQL, Redis, SQLite |
| Audio | 4 | WAV, MP3, ALSA-Wiedergabe |
| PDF-Bibliothek | 25 | PDF erstellen, lesen, Schriften, Sonderfarben, PDF/A |
| SVG-Bibliothek | 12 | Vektorgrafiken, Animationen, Filter, Parser |
| LFD-Binärformat | 2 | LFD-Dateien lesen und schreiben |
| Validierung | 25 | IBAN, EAN, ISIN, VIN, Personalausweis, Sozialversicherung |
| Hardware — Bluetooth | 9 | BLE, GATT, RFCOMM, Advertising, Mesh |
| Hardware — USB | 13 | Control/Bulk/Interrupt/ISO, typsichere EP-Wrapper, URB-Pool, Discovery |
| Hardware — GPIO | 8 | RPi4/BCM2711: MMIO-Direktzugriff, GPIO-v2 ioctl, SoftPWM, Edge-Detection |
| Android | 16 | NDK, JNI, OpenGL ES, APK-Bau, Sensoren |
| Cloud — AWS | 13 | S3, EC2, DynamoDB, Lambda, IAM, SQS, SNS, CloudWatch, Secrets Manager |
| Cloud — DigitalOcean | 13 | Droplets, Volumes, Spaces, Databases, Kubernetes, Apps, Networking |
| Cloud — Cloudflare | 16 | Zones, DNS, Workers, KV, R2, D1, WAF, Cache, Pages, Tunnel, Email, Analytics |
| Cloud — GCP | 11 | Cloud Storage, Compute Engine, Firestore, Pub/Sub, Cloud Functions, Cloud Run, Logging, Monitoring, Secret Manager, IAM |
| KassenSichV | 6 | TSE-Anbindung (Mock, Cloud REST, USB-File), BSI TR-03153 QR-Code, DSFinV-K-Export |
| Archiv | 4 | ZIP lesen/schreiben, TAR (POSIX ustar) lesen/schreiben, RAR5 lesen, ISO 9660 lesen/schreiben |
| Blockchain | 2 | Transaktion, Block, Ledger, PoW-Konsens, P2P-Netzwerk |
| CPU & SIMD | 2 | CPU-Feature-Erkennung (SSE2/SSE4.1/AVX2), Runtime-Dispatch, 16-Byte-ausgerichtete f32-Arrays (WP-GPU-02, in Entwicklung) |
| Bildverarbeitung | 9 | Einheitliches Bild-Lade-API (GRF-08): BMP, PNG, JPEG, GIF, TIFF, WebP, AVIF; Format-Auto-Erkennung, RGBA-Pixel-Zugriff |
| Office-Dokumente | 4 | ODF-Dokumente erstellen: ODT-Texte (Absätze, Überschriften, Formatierung) und ODS-Tabellen (Sheets, Zellen) |
| Video | 3 | Video-Metadaten aus AVI (VID-01) und MP4/ISOBMFF (VID-02); Codec-Erkennung (H.264/H.265/AV1/VP8/VP9/MJPEG); MJPEG-Frame-Extraktion |
| OpenPGP | 4 | RFC 4880: ASCII-Armor kodieren/dekodieren, Paket-Iteration, Public-Key-Fingerprint und Key-ID extrahieren |
| EDI / EDIFACT | 14 | B2B-Datenaustausch: Bestellungen, Rechnungen, Lieferscheine, Zoll, Seefracht, Transport, Zahlungsverkehr |
| HL7 v2 | 4 | Gesundheitswesen: MLLP-Framing, MSH/ACK-Engine, Patientenverwaltung (ADT), Aufträge (ORM/OML), Befunde (ORU/OUL) |
===== Import-Syntax =====
Units können einzeln oder als ganzer Namespace importiert werden:
// Einzelne Unit
import std.io;
import std.math;
// Mehrere Units aus demselben Namespace
import std.net.http;
import std.net.dns;
import std.crypto.aes;
// Wildcard: alle Units eines Namespace (praktisch für Entwicklung)
import std.audio.*;
// LyxVision (kein std.-Präfix)
import lyxvision.app;
import lyxvision.button;
Explizite Einzel-Imports sind für Produktionscode empfohlen: Der Compiler kann ungenutzte Symbole präziser warnen und das Linker-Ergebnis ist kleiner.
==== Vorkompilierte Units (*.lyu) ====
Units können mit dem Lyx-Compiler vorkompiliert werden. Das Ergebnis ist eine ''*.lyu''-Datei (Lyx Unit, binär), die bereits in die interne Zwischendarstellung übersetzt wurde:
lyxc --compile-unit std/math/math.lyx
# erzeugt: std/math/math.lyu
Beim Import sucht der Compiler automatisch nach der vorkompilierten Version:
* **''*.lyu'' vorhanden** → wird bevorzugt importiert (kein erneutes Parsen/Compilieren der Quelle)
* **nur ''*.lyx'' vorhanden** → Quellcode wird beim Build direkt mitcompiliert
Die Standardbibliothek wird in der Regel mit fertigen ''*.lyu''-Dateien ausgeliefert. Eigene Units bei häufiger Wiederverwendung ebenfalls vorkompilieren:
# Alle Units eines Projekts vorkompilieren
lyxc --compile-unit src/utils.lyx src/config.lyx src/protocol.lyx
-----
===== Grundsystem =====
Kern-Units, die von fast allen anderen Units als Basis verwendet werden. In sicherheitskritischem Code (''@flight_crit'', ''@dal(A/B)'') sind ''std.alloc'' und ''std.result'' die primären Bausteine für kontrollierte Ressourcen- und Fehlerbehandlung.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:alloc|std.alloc]] | Heap-Speicherverwaltung: ''malloc'', ''calloc'', ''realloc'', ''free'' mit 8-Byte-Alignment; ''malloc_safe'' gibt ''ResultInt64'' zurück; ''malloc_orpanic'' terminiert bei OOM |
| [[lyx_-_programmiersprache:units:system|std.system]] | Kern-Typen: ''Handle'' und ''FD'' als benannte int64-Aliases für OS-Handles und Dateideskriptoren |
| [[lyx_-_programmiersprache:units:error|std.error]] | POSIX-errno-Konstanten (1–133), ''GetErrorMessage'', ''CheckSyscallError'', ''GetSyscallErrorCode'' |
| [[lyx_-_programmiersprache:units:result|std.result]] | ''ResultInt64'', ''ResultBool'', ''OptionInt64'' u. a.; ''Unwrap'', ''UnwrapOr'', ''Expect'', ''AndThen'' für verkettete Fehlerbehandlung ohne Exceptions |
| [[lyx_-_programmiersprache:units:meta_safe|std.meta_safe]] | Binäre Integritätsprüfung: CRC32 über Code-Pages aus ''/proc/self/exe''; erkennt Modifikationen am Prozess-Image zur Laufzeit |
| [[lyx_-_programmiersprache:units:mmap_ext|std.mmap_ext]] | Erweiterte Memory-Operationen: ''mremap'', ''madvise'' (MADV_*), ''msync'', ''memfd_create'', ''mlock''/''munlock'', ''mincore'' |
| [[lyx_-_programmiersprache:units:inotify|std.inotify]] | Dateisystem-Ereignisse via Linux inotify: ''InotifyCreate'', ''InotifyWatch'', ''InotifyRead''; Event-Masken IN_CREATE, IN_MODIFY, IN_DELETE, IN_MOVED_*, IN_ALL_EVENTS |
| [[lyx_-_programmiersprache:units:mqueue|std.mqueue]] | POSIX Message Queues: ''MqOpen'', ''MqOpenWith'', ''MqSend'', ''MqTimedSend'', ''MqRecv'', ''MqTimedRecv'', ''MqGetCurMsgs'', ''MqUnlink'' |
import std.alloc;
import std.result;
fn AllocBuffer(size: int64): ResultInt64 {
var ptr := malloc_safe(size);
if (ResultInt64IsErr(ptr)) {
return ErrInt64(-1);
}
return ptr;
}
→ Details: [[lyx_-_programmiersprache:sprache:exception-handling|Fehlerbehandlung – Result, Option, SafeArithmetic]]
-----
===== I/O & Dateisystem =====
Vierzehn Units für Ein-/Ausgabe, Betriebssystem-Interaktion, nebenläufige Programmierung, Scheduling, Signale und IPC. ''std.io'' ist die am häufigsten importierte Unit in Lyx-Programmen.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:io|std.io]] | Ausgabefunktionen: ''Print'', ''PrintLn'', ''PrintF64'', ''PrintBool''; ''IntToStr'', ''FloatToStr'', ''BoolToStr''; ''Printf''-Varianten für 1–4 Argumente |
| [[lyx_-_programmiersprache:units:fs|std.fs]] | Datei-I/O über POSIX-Syscalls: ''FsOpen'', ''FsRead'', ''FsWrite'', ''FsClose'', ''FsDelete'', ''FsExists'', Pfad-Operationen |
| [[lyx_-_programmiersprache:units:os|std.os]] | Betriebssystem-Schnittstelle: ''Sleep'', ''GetPID'', ''GetEnv'', ''GetCWD'', ''Exec'', ''MemInfo'', Pfadprüfungen |
| [[lyx_-_programmiersprache:units:env|std.env]] | Kommandozeilenargumente aus ''argv'' parsen (''--key=value''-Format), ''GetArg'', ''HasFlag'' |
| [[lyx_-_programmiersprache:units:process|std.process]] | Prozessverwaltung: ''Fork'', ''Exec'', ''Spawn'', ''Wait'', ''Kill'', ''Shell'' (Befehl als String ausführen) |
| [[lyx_-_programmiersprache:units:thread|std.thread]] | POSIX-Threads: ''ThreadCreate'', ''ThreadJoin''; Mutex, Bedingungsvariablen, Thread-Local Storage, Shared Memory, Atomic-Operationen, CAS — [[lyx_-_programmiersprache:sprache:threads|→ Detailseite]] |
| [[lyx_-_programmiersprache:units:log|std.log]] | Strukturiertes Logging: 5 Level (DEBUG, INFO, WARN, ERROR, FATAL), Callback-Handler, Sektionsmarkierungen, Zeitstempel |
| [[lyx_-_programmiersprache:units:fs_ext|std.fs_ext]] | Erweitertes Datei-I/O: ''pread64'', ''pwrite64'', ''readv'', ''writev'', ''fstat'', ''sendfile'' für High-Performance-I/O |
| [[lyx_-_programmiersprache:units:pipe|std.pipe]] | Pipes und Dateideskriptor-Duplikation: ''pipe'', ''pipe2'', ''dup'', ''dup2'', ''dup3'' |
| [[lyx_-_programmiersprache:units:signals|std.signals]] | UNIX-Signal-Handling: ''sigaction'', ''sigprocmask'', ''signalfd'', ''kill'', ''tgkill'' |
| [[lyx_-_programmiersprache:units:process_ext|std.process_ext]] | Prozess-Credentials: ''GetUID'', ''GetGID'', ''GetEUID'', ''IsRoot'', ''SetUID'', ''SetGID'', ''SetSID'', ''SetPGID''; Systeminfo via ''uname'' |
| [[lyx_-_programmiersprache:units:sched|std.sched]] | Scheduling & CPU-Affinität: ''SchedYield'', ''SchedSetAffinity'', ''CpuSetAdd''/''Remove'', ''GetPriority'', ''SetPriority'', ''GetCurrentCPU'' |
| [[lyx_-_programmiersprache:units:inotify|std.inotify]] | Dateisystem-Ereignisse (inotify): ''InotifyCreate'', ''InotifyWatch'', ''InotifyUnwatch'', ''InotifyRead''; Accessor-Funktionen für inotify_event-Felder |
| [[lyx_-_programmiersprache:units:mqueue|std.mqueue]] | POSIX Message Queues (IPC): ''MqOpen''/''MqOpenWith'', ''MqSend''/''MqTimedSend'', ''MqRecv''/''MqTimedRecv'', ''MqGetAttr'', ''MqGetCurMsgs'', ''MqUnlink'' |
| [[lyx_-_programmiersprache:units:xattr|std.xattr]] | Erweiterte Dateiattribute (xattr), Dateisystem-Statistik (''StatFs'', ''StatFsFreeBytes''), Speicher-Vorabzuweisung (''FileAllocate'', Hole-Punching) |
import std.io;
import std.fs;
import std.log;
fn main(): int64 {
// Ausgabe
PrintLn("Starte Programm" + IntToStr(42));
// Datei lesen
var fd := FsOpen("config.ini", FS_READ);
var buf: [1024]uint8;
var n := FsRead(fd, ^buf[0], 1024);
FsClose(fd);
// Logging
log_info("Konfiguration geladen");
return 0;
}
-----
===== Zeit =====
Zwei komplementäre Units: ''std.time'' für Zeitwerte und hochauflösende Messungen, ''std.datetime'' für menschenlesbare Formatierung und Parsing.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:time|std.time]] | Datum/Zeit-Typen, Unix-Zeitstempel (Sekunden und Mikrosekunden), hochauflösende Timer (''TimeNowMicros''), Zeitzonen-Offset |
| [[lyx_-_programmiersprache:units:datetime|std.datetime]] | Formatierung (ISO 8601, RFC 2822, relative Zeitangaben) und Parsing von Datums-/Zeitstrings; ''FormatDate'', ''ParseDate'' |
import std.time;
import std.datetime;
import std.io;
fn Benchmark() {
var start := TimeNowMicros();
HeavyComputation();
var elapsed := TimeNowMicros() - start;
PrintLn("Dauer: " + IntToStr(elapsed) + " µs");
}
fn LogTimestamp() {
var ts := TimeNow();
Print(FormatDate(ts, "ISO8601")); // "2026-05-22T14:30:00Z"
}
-----
===== Strings & Textverarbeitung =====
Fünf Units für alle Aspekte der Textverarbeitung – von einfachen String-Operationen über reguläre Ausdrücke bis zu URL-Parsing und Base64-Kodierung.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:string|std.string]] | String-Operationen: ''StrLen'', ''StrCopy'', ''StrConcat'', ''StrFind'', ''StrReplace'', ''StrTrim'', ''StrSplit'', ''ToUpper'', ''ToLower''; ''StringBuilder'' für effizientes Zusammensetzen |
| [[lyx_-_programmiersprache:units:regex|std.regex]] | Reguläre Ausdrücke: ''RegexMatch'', ''RegexSearch'', ''RegexReplace'', Capture-Gruppen, Flags (case-insensitive, multiline) |
| [[lyx_-_programmiersprache:units:html|std.html]] | HTML-Escape/Unescape, Tag-Erkennung, ''StripTags'', Validierung der Tag-Balance |
| [[lyx_-_programmiersprache:units:url|std.url]] | URL-Parsing nach RFC 3986: Schema, Host, Pfad, Query-Parameter; Prozent-Kodierung, ''UrlBuild'' |
| [[lyx_-_programmiersprache:units:base64|std.base64]] | Base64-Kodierung/Dekodierung (Standard und URL-Safe), Basic-Auth-Header, Data-URLs |
import std.string;
import std.regex;
fn ExtractVersion(input: pchar): pchar {
// Suche nach "v1.2.3"-Muster
var match := RegexSearch(input, "v([0-9]+\\.[0-9]+\\.[0-9]+)");
if (match.found) {
return match.group[1]; // Capture-Gruppe 1
}
return "unbekannt";
}
fn Normalize(s: pchar): pchar {
return s |> StrTrim() |> ToLower();
}
-----
===== Datenformate =====
Vier Units zum Lesen und Schreiben strukturierter Dateiformat – JSON und YAML für Web/Config, XML für Legacy-Systeme und Protokolle, INI für einfache Konfigurationsdateien.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:json|std.json]] | JSON-Parser und -Serialisierer: ''JsonParse'', ''JsonGet'', ''JsonSet'', ''JsonToStr''; alle JSON-Typen (Objekt, Array, String, Zahl, Bool, null) |
| [[lyx_-_programmiersprache:units:xml|std.xml]] | XML-Parser und -Generator: Elemente, Attribute, Namespace, Pretty-Print, Basis-Validierung |
| [[lyx_-_programmiersprache:units:yaml|std.yaml]] | YAML-Parser: Skalare, Sequenzen, Maps; pfadbasierter Zugriff (''YamlGetPath''), Datei-Load/Save |
| [[lyx_-_programmiersprache:units:ini|std.ini]] | INI-Konfigurationsdateien: Sektionen, typisierte Getter (''IniGetStr'', ''IniGetInt'', ''IniGetBool''), Datei-Load/Save |
import std.ini;
import std.io;
fn LoadConfig(): int64 {
var cfg := IniLoad("config.ini");
var port := IniGetInt(cfg, "server", "port", 8080);
var host := IniGetStr(cfg, "server", "host", "localhost");
var debug := IniGetBool(cfg, "app", "debug", false);
Print(host + IntToStr(port));
return 0;
}
-----
===== Datenstrukturen & Algorithmen =====
Acht Units für Kernalgorithmen und Low-Level-Datenoperationen. Alle Units in dieser Kategorie sind vollständig in Lyx implementiert – keine externen Abhängigkeiten.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:buffer|std.buffer]] | Byte-Buffer-Operationen: ''BufCopy'', ''BufFill'', ''BufFind'', ''BufReverse'', Hex-Kodierung/Dekodierung |
| [[lyx_-_programmiersprache:units:list|std.list]] | Datenstrukturen für int64 und Vec2: dynamische Liste, ''StaticList'' (Stack-alloziert), Stack, Queue, RingBuffer |
| [[lyx_-_programmiersprache:units:hash|std.hash]] | Hash-Funktionen: FNV1a, MD5, SHA-256, SHA-3 (256/512), BLAKE3; Passwort-Hashing: bcrypt, Argon2, scrypt |
| [[lyx_-_programmiersprache:units:sort|std.sort]] | QuickSort für int64-Arrays (Median-of-Three-Pivot, Insertion-Sort-Fallback bei n ≤ 16) |
| [[lyx_-_programmiersprache:units:stats|std.stats]] | Array-Statistik: ''Sum'', ''Min'', ''Max'', ''Avg'', ''Median'', ''Variance'', ''StdDev'' |
| [[lyx_-_programmiersprache:units:stats_batch|std.stats_batch]] | Batch-Statistik für 4 oder 8 direkt übergebene Werte (ohne Array-Allokation, SIMD-freundlich) |
| [[lyx_-_programmiersprache:units:pack|std.pack]] | Binäres Serialisieren/Deserialisieren: VarInt (LEB128), Int8–64, Float, String, Arrays; Little/Big-Endian |
| [[lyx_-_programmiersprache:units:zlib|std.zlib]] | DEFLATE/zlib-Kompression (RFC 1950/1951): ''Compress'', ''Decompress'', LZ77, Adler-32, CRC32 |
| [[lyx_-_programmiersprache:units:brotli|std.brotli]] | Brotli (RFC 7932): ''BrotliDecompress'' (vollständig), ''BrotliCompress'' (Store-Modus); kein std.zlib-Aufruf, keine externen Abhängigkeiten |
| [[lyx_-_programmiersprache:units:zstd|std.zstd]] | Zstandard (RFC 8878): ''ZstdDecompress'' (vollständig, FSE+Huffman), ''ZstdCompress'' (Store-Modus, Raw-Blöcke à 128 KB); Frame enthält Content Size |
-----
===== Archiv =====
Vier Units zum Lesen und Schreiben von Archivformaten. ZIP und TAR unterstützen sowohl Lesen als auch Schreiben; RAR5 ist wegen der proprietären Kompression nur lesbar; ISO 9660 liest den vollständigen Verzeichnisbaum und schreibt Flat-Root-Images.
→ [[lyx_-_programmiersprache:units:archiv|Archiv-Übersicht]]
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:zip|std.zip]] | ZIP lesen (stored + deflated) und schreiben (automatische Methode); max. 4096 Einträge, kein ZIP64 |
| [[lyx_-_programmiersprache:units:tar|std.tar]] | TAR lesen und schreiben (POSIX ustar); keine Kompression — mit ''std.zlib'' für .tar.gz kombinieren |
| [[lyx_-_programmiersprache:units:rar|std.rar]] | RAR5 lesen (nur stored-Einträge); kein Writer — RAR-Erstellung erfordert RARLAB-Lizenz |
| [[lyx_-_programmiersprache:units:iso|std.iso]] | ISO 9660 Level 1 lesen (BFS, vollständige Pfade, max. 256 Verz.) und schreiben (Flat-Root, Name-Normalisierung) |
import std.zip;
fn ZipRoundtrip(): void {
// Schreiben
var w: int64 := ZipWriterNew();
ZipWriterAdd(w, "hello.txt"c as int64, "Hallo!"c as int64, 6);
ZipWriterSave(w, "test.zip"c as int64);
ZipWriterFree(w);
// Lesen
var z: int64 := ZipOpen("test.zip"c as int64);
var buf: int64 := alloc(ZipUncompSize(z, 0) + 1);
ZipRead(z, 0, buf, ZipUncompSize(z, 0));
PrintLn(buf as pchar);
free(buf, ZipUncompSize(z, 0) + 1);
ZipClose(z);
}
-----
import std.list;
import std.sort;
import std.stats;
fn AnalyzeSamples() {
var buf: [64]int64;
// … Werte befüllen …
QuickSort(buf, 64);
PrintFloat(Avg(buf, 64));
PrintFloat(Median(buf, 64));
PrintFloat(StdDev(buf, 64));
}
-----
===== Geometrie & Grafik =====
Sieben Units von 2D-Vektormathematik über GPS-Koordinaten bis zum direkten X11-Fensterzugriff.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:vector|std.vector]] | Vec2-Vektormathematik: ''Add'', ''Sub'', ''Scale'', ''Dot'', ''Cross'', ''Normalize'', ''Rotate'', ''Lerp'', ''Length'' |
| [[lyx_-_programmiersprache:units:vector_batch|std.vector_batch]] | Batch-Operationen auf Vec2-Arrays: Summe, Skalierung, Normalisierung (SIMD-optimiert) |
| [[lyx_-_programmiersprache:units:rect|std.rect]] | Rechteck-Geometrie: ''Contains'', ''Inflate'', ''Union'', ''Intersect'', ''Clamp'' |
| [[lyx_-_programmiersprache:units:circle|std.circle]] | Kreis-Geometrie, 1D/2D-Bereichstypen (''Range'', ''Range2D''), Überlappungsprüfung |
| [[lyx_-_programmiersprache:units:color|std.color]] | RGBA-Farben (uint32-gepackt): ''Blend'', ''ToHSL'', ''FromHSL'', ''Brighten'', ''Saturate'', ''Lerp'' |
| [[lyx_-_programmiersprache:units:geo|std.geo]] | GPS-Koordinaten (WGS-84): Haversine-Distanz, Bearing, Bounding-Boxes, Dezimal/DMS-Konvertierung |
| [[lyx_-_programmiersprache:units:x11|std.x11]] | X11-Fenster-System (direkte Xcb/Xlib-Syscalls): Display öffnen, Fenster erstellen, Zeichnen, Tastatur-/Mausereignisse |
import std.vector;
import std.geo;
import std.io;
fn PathLength(points: [16]Vec2, count: int64): f64 {
var total: f64 := 0.0;
for i := 1 to count - 1 do {
var d := Sub(points[i], points[i - 1]);
total := total + Length(d);
}
return total;
}
fn DistanceKm(lat1: f64, lon1: f64, lat2: f64, lon2: f64): f64 {
return GeoHaversine(lat1, lon1, lat2, lon2); // in Metern / 1000
}
-----
===== Terminal =====
Zwei Units für die direkte Terminal-Steuerung: ''std.crt'' für Ausgabe mit ANSI-Farben und Cursor-Kontrolle, ''std.crt_raw'' für zeichenweises non-blocking Lesen im Raw-Modus.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:crt|std.crt]] | Terminal-Ausgabe: ANSI-Farben (16 Vordergrund-/Hintergrundfarben), Cursor-Positionierung, Bildschirm löschen, ''CrtGoto'', ''CrtSetColor'' |
| [[lyx_-_programmiersprache:units:crt_raw|std.crt_raw]] | Roh-Terminal-I/O: Raw-Modus via ''tcgetattr''/''tcsetattr'', zeichenweises non-blocking Lesen, Escape-Sequenz-Erkennung |
import std.crt;
fn PrintHeader(title: pchar) {
CrtSetColor(CRT_GREEN, CRT_BLACK);
CrtGoto(1, 1);
Print(title);
CrtSetColor(CRT_DEFAULT, CRT_DEFAULT);
}
→ Für vollständige TUI-Anwendungen: [[lyx_-_programmiersprache:units:lyxvision:app|LyxVision-Framework]]
-----
===== Audio =====
Vier Units für Audio-Verarbeitung und -Wiedergabe. ''std.audio.alsa'' und ''std.audio.mpg123'' setzen die entsprechenden Systembibliotheken voraus.
^ Unit ^ Abhängigkeit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:audio|std.audio]] | keine | Audio-Basis: ''AudioInfo''-Typ, WAV-Parser, WAV-Schreiben, PCM-Format-Konvertierung, MP3-Header-Erkennung |
| [[lyx_-_programmiersprache:units:audio:alsa|std.audio.alsa]] | libasound | ALSA-Soundkarte: direkte PCM-Wiedergabe und Aufnahme über Kernel-Interface, Buffer-Konfiguration |
| [[lyx_-_programmiersprache:units:audio:mpg123|std.audio.mpg123]] | libmpg123 | MP3-Dekodierung via mpg123-Bibliothek, Stream-basiert, automatisches Resampling |
| [[lyx_-_programmiersprache:units:audio:playback|std.audio.playback]] | aplay/ALSA | Vereinfachte WAV-Wiedergabe: ''PlayWav(filename)'' ohne manuelle ALSA-Konfiguration |
import std.audio.playback;
fn PlayNotification() {
PlayWav("assets/notify.wav");
}
-----
===== Kryptografie =====
Sechs Units für kryptografische Grundoperationen: Verschlüsselung, Hashing, digitale Signaturen und sichere Zufallszahlen. Für TLS/HTTPS-Verbindungen wird OpenSSL via ''std.net.tls'' genutzt.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:crypto:aes|std.crypto.aes]] | AES-128/256 im CBC-Modus: ''AES128CBCEncrypt'', ''AES128CBCDecrypt'', ''AES256CBCEncrypt'', ''AES256CBCDecrypt''; PKCS#7-Padding, IV-basiert |
| [[lyx_-_programmiersprache:units:crypto:sha256|std.crypto.sha256]] | SHA-256 (FIPS 180-4): ''SHA256'' (32-Byte-Digest), ''SHA256Hex'' (64-Zeichen-Hex), ''SHA256Str''; für Signaturen und Datenintegrität |
| [[lyx_-_programmiersprache:units:crypto:ecc|std.crypto.ecc]] | secp256k1 ECDSA: ''ECCGenKey'', ''ECCPubFromPriv'', ''ECDSASign'', ''ECDSAVerify''; Bitcoin/Ethereum-Kurve, Little-Endian-Puffer |
| [[lyx_-_programmiersprache:units:crypto:rand|std.crypto.rand]] | Sichere Zufallszahlen via ''getrandom(2)'': ''RandBytes'', ''RandBytesExact'', ''RandInt64'', ''RandU32''; kein /dev/urandom-FD nötig |
| [[lyx_-_programmiersprache:units:crypto:hmac|std.crypto.hmac]] | HMAC-SHA256 (RFC 2104): ''HMAC_SHA256'' (32-Byte-MAC), ''HMAC_SHA256_Hex''; Integrität + Authentizität; Encrypt-then-MAC mit AES-CBC |
| [[lyx_-_programmiersprache:units:crypto:md5|std.crypto.md5]] | MD5 (RFC 1321): ''MD5'', ''MD5Hex'' (32-Zeichen Lowercase-Hex); Legacy-Einsatz (Prüfsummen, HTTP Digest Auth) |
| [[lyx_-_programmiersprache:units:crypto:sha1|std.crypto.sha1]] | SHA-1 (160-Bit-Hash): ''SHA1'', ''SHA1MySQLNativePassword''; Legacy-Einsatz (MySQL ''mysql_native_password'', Git-Objekt-IDs) |
| [[lyx_-_programmiersprache:units:crypto:x25519|std.crypto.x25519]] | X25519 Diffie-Hellman (Curve25519, RFC 7748): ''X25519KeyGen'', ''X25519SharedSecret'', ''X25519''; constant-time Montgomery-Leiter; PK/SK/SS je 32 Byte |
| [[lyx_-_programmiersprache:units:crypto:keccak|std.crypto.keccak]] | Keccak-f[1600] / SHA-3 (FIPS 202): ''SHA3_256'', ''SHA3_512'', ''SHAKE128'', ''SHAKE256'' (XOF); Low-Level: ''KeccakInit'', ''KeccakAbsorb'', ''KeccakSqueeze'' |
| [[lyx_-_programmiersprache:units:crypto:ct|std.crypto.ct]] | Constant-Time Utilities: ''CTSelect'', ''CTMemEqual'', ''SecureZero'', ''CTBarrettReduce'', ''CTMontgomeryReduce''; Schutz vor Timing-Angriffen |
| [[lyx_-_programmiersprache:units:crypto:ntt|std.crypto.ntt]] | NTT-Polynomring-Arithmetik für ML-KEM (q=3329) und ML-DSA (q=8380417): ''KyberNTT'', ''DilithiumNTT'', ''KyberPolyMul'' u. a. — interne PQC-Implementierungseinheit |
| [[lyx_-_programmiersprache:units:crypto:pqc|std.crypto.pqc]] | Post-Quantum High-Level API: ''PQCKeyGen'', ''PQCEncapsulate'', ''PQCDecapsulate'', ''PQCSign'', ''PQCVerify''; Fassade über alle FIPS-203/204/205-Units |
| [[lyx_-_programmiersprache:units:crypto:pqc:mlkem|std.crypto.pqc.mlkem]] | ML-KEM (CRYSTALS-Kyber, FIPS 203): ''MLKEMKeyGen'', ''MLKEMEncapsulate'', ''MLKEMDecapsulate''; k=2/3/4 für 512/768/1024; ersetzt ECDH |
| [[lyx_-_programmiersprache:units:crypto:pqc:mldsa|std.crypto.pqc.mldsa]] | ML-DSA (CRYSTALS-Dilithium, FIPS 204): ''MLDSAKeyGen'', ''MLDSASign'', ''MLDSAVerify''; level=44/65/87; ersetzt ECDSA |
| [[lyx_-_programmiersprache:units:crypto:pqc:slhdsa|std.crypto.pqc.slhdsa]] | SLH-DSA (SPHINCS+, FIPS 205): ''SLHDSAKeyGen'', ''SLHDSASign'', ''SLHDSAVerify''; SHA-256-basiert; PK nur 32 B |
| [[lyx_-_programmiersprache:units:crypto:pqc:hybrid|std.crypto.pqc.hybrid]] | Hybrid-KEM (X25519+ML-KEM-768): ''HybridKEMKeyGen'', ''HybridKEMEncapsulate'', ''HybridKEMDecapsulate''; Signal/Apple PQ3-Schema |
| [[lyx_-_programmiersprache:units:crypto:pqc:dadq|std.crypto.pqc.dadq]] | DADQ-SYM (symmetrisches Authenticated Cipher, experimentell): ''dadqFOEnc'', ''dadqFODec'' (FO-Modus); Latin-Square Z₂₅₆, 128-Bit Quantensicherheit (Grover) |
→ Übersicht: [[lyx_-_programmiersprache:units:crypto|std.crypto Paket]] · PQC-Kategorie: [[lyx_-_programmiersprache:units:crypto:pqc|std.crypto.pqc]] · Stärkere Hash-Funktionen und Passwort-Hashing: [[lyx_-_programmiersprache:units:hash|std.hash]]
-----
===== System & Kernel =====
Sieben Units für Linux-Kernel-Schnittstellen: asynchrones I/O, Inter-Prozess-Kommunikation, Tracing, BPF-Programme, Namespaces, Capabilities und System-Administration.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:io_uring|std.io_uring]] | Asynchrones I/O (Kernel 5.1+): ''IoUringCreate'', ''IoUringGetSQE'', ''IoUringSubmit'', ''IoUringWaitCQE''; Read/Write/NOP-SQEs; SINGLE_MMAP |
| [[lyx_-_programmiersprache:units:ipc_sysv|std.ipc_sysv]] | SysV IPC: Shared Memory (''ShmCreate/Attach/Detach/Delete''), Semaphore (''SemWait/Post''), Message Queues (''MsgSend/Recv'') |
| [[lyx_-_programmiersprache:units:bpf|std.bpf]] | eBPF: ''BpfMapCreate'', ''BpfMapLookup/Update/Delete'', ''BpfProgLoad'', ''BpfInsn''; Maps (Hash, Array, Ringbuf), Programme (XDP, kprobe) |
| [[lyx_-_programmiersprache:units:debug|std.debug]] | Debugging & Performance: ptrace (''PtraceAttach'', ''PtracePeek/Poke'', ''PtraceGetRegs''), perf_event_open (''PerfCount'', ''PerfRead'') |
| [[lyx_-_programmiersprache:units:ns|std.ns]] | Namespaces & pidfd: ''PidFdOpen'', ''PidFdSendSignal'', ''PidFdGetFd'', ''NamespaceUnshare'', ''NamespaceJoin''; CLONE_NEW* |
| [[lyx_-_programmiersprache:units:security_ext|std.security_ext]] | Capabilities & prctl: ''ProcessSetName'', ''ProcessSetNoNewPrivs'', ''CapGet'', ''CapSet'', ''CapDrop'', ''CapIsSet''; ''ArchGetFs/Gs'' |
| [[lyx_-_programmiersprache:units:sysadmin|std.sysadmin]] | Systemverwaltung (root): ''Mount'', ''Umount'', ''Chroot'', ''SetHostname'', ''SyncAll'', ''Reboot''; MS_*-Flags |
-----
===== Datenbanken =====
Fünf Units für direkte Datenbankverbindungen ohne ORM-Schicht. Alle Protokolle sind nativ in Lyx implementiert — keine externen Client-Bibliotheken erforderlich (Ausnahme: ''std.db.sqlite'' via libsqlite3).
^ Unit ^ Port ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:db:mysql|std.db.mysql]] | 3306 | MySQL/MariaDB-Client über Protokoll 41 (TCP): Verbindungsaufbau, Abfragen, Prepared Statements, Ergebnis-Iteration |
| [[lyx_-_programmiersprache:units:db:postgres|std.db.postgres]] | 5432 | PostgreSQL-Client (Frontend/Backend Protocol v3, ohne libpq): Verbindungsaufbau, Abfragen, Ergebnis-Iteration |
| [[lyx_-_programmiersprache:units:db:redis|std.db.redis]] | 6379 | Redis-Client via RESP-Protokoll (voll): Strings, Lists, Hashes, Sets, Sorted Sets, Pub/Sub, Expire, Pipelining |
| [[lyx_-_programmiersprache:units:db:redis_simple|std.db.redis_simple]] | 6379 | Redis-Client (minimal): nur GET/SET/DEL/EXPIRE — für eingeschränkte Umgebungen ohne std.string-Abhängigkeit |
| [[lyx_-_programmiersprache:units:db:sqlite|std.db.sqlite]] | — | SQLite3 FFI-Bindings via libsqlite3: Verbindung, Abfragen, Prepared Statements, Ergebnis-Iteration |
===== Graphdatenbank =====
In-Memory-Graphdatenbank ohne externe Abhängigkeiten. Nodes + Kanten mit typisierten Properties, f64-Embedding-Vektoren, drei Indizes (temporal, typ-basiert, Vektorähnlichkeit) und Graph-RAG-Funktion für KI-Kontext-Retrieval.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:graphdb|std.graphdb]] | In-Memory-Graph: Nodes, Kanten, Labels, TLV-Properties, Vektoren, Indizes, Datei-Persistenz, Graph-RAG |
import std.db.mysql;
fn GetUserCount(): int64 {
var conn := MysqlConnect("localhost", "app", "secret", "mydb");
var result := MysqlQuery(conn, "SELECT COUNT(*) FROM users");
var count := MysqlGetInt(result, 0, 0);
MysqlClose(conn);
return count;
}
-----
===== Mathematik =====
Drei Units für mathematische Grundfunktionen. ''std.math.constants'' ergänzt typisierte Konstanten. ''std.math_batch'' ist speziell für SIMD-optimierte Mehrfach-Operationen.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:math|std.math]] | Ganzzahl- und Gleitkomma-Mathematik: ''Abs'', ''Min'', ''Max'', ''Sqrt'', ''Sin'', ''Cos'', ''Tan'', ''Lerp'', ''Map'', ''Clamp'', ''Pow'', ''Atan2'', ''Floor'', ''Ceil'', ''Round'' |
| [[lyx_-_programmiersprache:units:math_batch|std.math_batch]] | Batch-Min/Max/Clamp für 4 oder 8 Argumente gleichzeitig – ohne Array-Overhead, SIMD-freundlich |
| [[lyx_-_programmiersprache:units:math:constants|std.math.constants]] | Typisierte mathematische Konstanten: π, e, √2, φ (Goldener Schnitt), Tau; Grad-/Radiant-Konvertierung |
import std.math;
import std.math.constants;
fn CircleArea(r: f64): f64 {
return PI * r * r;
}
fn NormalizeAngle(deg: f64): f64 {
return Clamp(deg, 0.0, 360.0) |> DegToRad();
}
-----
===== Netzwerk & Protokolle =====
26 Units in vier Gruppen: Transportschicht (Sockets, TLS, epoll), Anwendungsprotokolle, Verzeichnisdienste und Netzwerk-Management. Die Units bauen aufeinander auf: HTTP nutzt Socket, HTTPS nutzt TLS, REST-Client baut auf HTTP + HTTPS auf.
^ Unit ^ Gruppe ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:net:socket|std.net.socket]] | Transport | TCP, UDP, Unix, Raw-Sockets, ICMP, ARP; ''Poll'', ''Select'' für non-blocking I/O |
| [[lyx_-_programmiersprache:units:net:types|std.net.types]] | Transport | Socket-Adresstypen (''SockAddr4'', ''SockAddr6''), IP-Hilfsfunktionen (''IpFromStr'', ''IpToStr'') |
| [[lyx_-_programmiersprache:units:net:tls|std.net.tls]] | Transport | TLS/SSL-Verbindungen (via OpenSSL): Handshake, Zertifikat-Prüfung, Lesen/Schreiben |
| [[lyx_-_programmiersprache:units:net:syscalls|std.net.syscalls]] | Transport | Portable POSIX-Socket-Syscall-Wrapper (unterste Schicht; selten direkt verwendet) |
| [[lyx_-_programmiersprache:units:net:epoll|std.net.epoll]] | Transport | epoll I/O-Multiplexing: ''epoll_create1'', ''epoll_ctl'', ''epoll_wait'', ''eventfd2'' |
| [[lyx_-_programmiersprache:units:net:dns|std.net.dns]] | Protokolle | DNS-Auflösung: A, AAAA, MX, NS, TXT, SOA, SRV, CAA, DNSKEY, DS, PTR |
| [[lyx_-_programmiersprache:units:net:http|std.net.http]] | Protokolle | HTTP/1.1-Client: GET, POST, PUT, DELETE; Header, Chunked-Transfer, Redirect-Follow |
| [[lyx_-_programmiersprache:units:net:https|std.net.https]] | Protokolle | HTTPS-Client (baut auf ''std.net.tls'' auf); identische API wie ''std.net.http'' |
| [[lyx_-_programmiersprache:units:net:rest|std.net.rest]] | Protokolle | Session-basierter REST-Client: Base-URL, Bearer/API-Key-Auth, JSON-Shortcuts, Query-Builder |
| [[lyx_-_programmiersprache:units:net:smtp|std.net.smtp]] | Protokolle | SMTP-Mailversand (Ports 25/587/465): vollständiger Dialog, STARTTLS, AUTH LOGIN |
| [[lyx_-_programmiersprache:units:net:imap|std.net.imap]] | Protokolle | IMAP4rev1-Postfachzugriff: SELECT, LIST, FETCH, SEARCH, tagged Responses |
| [[lyx_-_programmiersprache:units:net:ssh|std.net.ssh]] | Protokolle | SSH-Verbindung: Passwort- und Key-Auth, Remote-Befehlsausführung, Output-Capture |
| [[lyx_-_programmiersprache:units:net:mqtt|std.net.mqtt]] | Protokolle | MQTT 3.1.1: Connect, Publish, Subscribe, QoS 0/1/2 – für IoT-Geräte |
| [[lyx_-_programmiersprache:units:net:ntp|std.net.ntp]] | Protokolle | NTP v3: Zeitabfrage via UDP Port 123, Offset-Berechnung |
| [[lyx_-_programmiersprache:units:net:quic|std.net.quic]] | Protokolle | QUIC (RFC 9000): UDP-basiert, TLS 1.3 integriert, Grundlage für HTTP/3-Transport |
| [[lyx_-_programmiersprache:units:net:sip|std.net.sip]] | Protokolle | SIP (RFC 3261): REGISTER, INVITE, OPTIONS; 1xx–6xx-Statusklassen (VoIP) |
| [[lyx_-_programmiersprache:units:net:telnet|std.net.telnet]] | Protokolle | Telnet (RFC 854): Option-Negotiation, Legacy-Gerätekommunikation (Switches, PLCs) |
| [[lyx_-_programmiersprache:units:net:whois|std.net.whois]] | Protokolle | WHOIS (RFC 3912): Auto-Routing zu Registry-Servern (.com/.de/.eu/IP) |
| [[lyx_-_programmiersprache:units:net:ldap|std.net.ldap]] | Verzeichnis | LDAP (RFC 4511): Bind, Search, Modify, Add, Delete, SASL-Auth (Active Directory / OpenLDAP) |
| [[lyx_-_programmiersprache:units:net:bgp|std.net.bgp]] | Routing | BGP-4 (RFC 4271): FSM IDLE→ESTABLISHED, AS-Routing, UPDATE-Messages, Path-Attribute |
| [[lyx_-_programmiersprache:units:net:snmp|std.net.snmp]] | Management | SNMPv1/v2c: OID-basierter Geräteparameter-Zugriff (GET/SET/WALK) |
| [[lyx_-_programmiersprache:units:net:asn1|std.net.asn1]] | Management | ASN.1/BER-Encoding für SNMP-PDUs (interne Hilfsbibliothek, selten direkt verwendet) |
| [[lyx_-_programmiersprache:units:net:mongo|std.net.mongo]] | Datenbank | MongoDB Wire Protocol: BSON-Dokumente, Insert/Find/Update/Delete, SCRAM-SHA-1-Auth |
| ''std.net.internal.syscalls_linux'' | Intern | Linux-spezifische Socket-Syscall-Wrapper — wird automatisch von std.net.syscalls gezogen |
| ''std.net.internal.syscalls_android'' | Intern | Android-spezifische Socket-Syscall-Wrapper (ARM64/x86_64) |
| ''std.net.internal.types'' | Intern | Interne Networking-Typ-Aliases — nicht direkt importieren |
import std.net.https;
import std.json;
fn FetchWeather(city: pchar): f64 {
var resp := HttpsGet("api.example.com", "/weather?city=" + city);
var data := JsonParse(resp.body);
return JsonGetFloat(data, "temperature");
}
-----
===== Validierung =====
25 Units für Prüfziffern und internationale Identifikationsnummern. Alle Units folgen dem gleichen Muster: Normalisierung → Validierung → Fehlercode. Keine externen Abhängigkeiten — vollständig in Lyx implementiert.
→ Details: [[lyx_-_programmiersprache:units:validate|std.validate Übersicht]]
==== Basis ====
Grundlegende Funktionen:
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:ean|std.validate.ean]] | EAN-8/13/14, UPC-A Barcode-Validierung mit Prüfziffer-Berechnung und Länder-Präfix-Erkennung |
| [[lyx_-_programmiersprache:units:validate:iban|std.validate.iban]] | IBAN-Validierung (Mod-97-Algorithmus, 30+ Länder), Bankleitzahl- und Kontonummer-Extraktion |
| [[lyx_-_programmiersprache:units:validate:isbn|std.validate.isbn]] | ISBN-10/13-Validierung, bidirektionale Konvertierung (10↔13), ISSN-Support |
| [[lyx_-_programmiersprache:units:validate:luhn|std.validate.luhn]] | Luhn-Algorithmus: Kreditkarten (Typ-Erkennung: Visa/MC/Amex/…), IMEI, deutsche Steuer-ID |
| [[lyx_-_programmiersprache:units:validate:vat|std.validate.vat]] | EU-Umsatzsteuer-ID-Validierung für alle 26 EU-Mitgliedstaaten (Muster + Prüfziffer) |
==== Deutsche Nummern ====
Validierungsfunktionen für deutsche Nummernformate:
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:de_personal|std.validate.de_personal]] | MRZ, Steuer-ID, Rentenversicherungsnummer (RVNR), eGK-Versichertennummer |
| [[lyx_-_programmiersprache:units:validate:de_numbers|std.validate.de_numbers]] | PZN (Arzneimittel), WKN (Wertpapiere), AGS (Gemeindeschlüssel), Zählpunktbezeichnung |
==== Internationale Wertpapiere & Finanz ====
Finanz- und Wertpapiervalidierungen:
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:isin|std.validate.isin]] | ISIN (ISO 6166) — weltweite Wertpapierkennung, Luhn auf erweiterter Ziffernkette |
| [[lyx_-_programmiersprache:units:validate:lei|std.validate.lei]] | LEI (ISO 17442) — Legal Entity Identifier, Mod-97 wie IBAN |
| [[lyx_-_programmiersprache:units:validate:bic|std.validate.bic]] | BIC/SWIFT-Code (ISO 9362) — strukturelle Bankidentifikation |
| [[lyx_-_programmiersprache:units:validate:us_cusip|std.validate.us_cusip]] | CUSIP — US/kanadische Wertpapierkennung, gewichtetes Mod-10 |
==== Fahrzeuge & Transport ====
Validierungen für Fahrzeug- und Transportidentifikatoren:
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:vin|std.validate.vin]] | VIN/FIN (FMVSS 565, ISO 3779) — Fahrzeugidentifikationsnummer, Mod-11 |
| [[lyx_-_programmiersprache:units:validate:iso6346|std.validate.iso6346]] | ISO 6346 — Schiffscontainer-Nummer, Zweierpotenzen Mod-11 |
| [[lyx_-_programmiersprache:units:validate:uic|std.validate.uic]] | UIC-Fahrzeugnummer — Eisenbahnfahrzeuge, Luhn Mod-10 |
| [[lyx_-_programmiersprache:units:validate:iata|std.validate.iata]] | IATA-Ticketnummer und Air Waybill — Mod-7 |
| [[lyx_-_programmiersprache:units:validate:mmsi|std.validate.mmsi]] | MMSI — Seefunk-Identifikation, ITU MID strukturell |
==== Wissenschaft & Publikationen ====
Validierungen für wissenschaftliche Identifikatoren:
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:issn|std.validate.issn]] | ISSN (ISO 3297) — Zeitschriften, Mod-11 |
| [[lyx_-_programmiersprache:units:validate:ismn|std.validate.ismn]] | ISMN (ISO 10957) — Notendrucke, EAN-13-Profil Präfix 9790 |
| [[lyx_-_programmiersprache:units:validate:isrc|std.validate.isrc]] | ISRC (ISO 3901) — Tonaufnahmen, strukturell CC-XXX-YY-NNNNN |
| [[lyx_-_programmiersprache:units:validate:orcid|std.validate.orcid]] | ORCID iD — Wissenschaftler-ID, ISO/IEC 7064 MOD 11-2 |
| [[lyx_-_programmiersprache:units:validate:cas|std.validate.cas]] | CAS-Nummer — chemische Verbindungen, rechtsseitig gewichtetes Mod-10 |
==== Länderspezifisch ====
Länderspezifische Validierungen:
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:nl_bsn|std.validate.nl_bsn]] | NL BSN (Burgerservicenummer) — 9-Proef Mod-11 |
| [[lyx_-_programmiersprache:units:validate:ch_ahv|std.validate.ch_ahv]] | CH AHV-Nummer — EAN-13 Mod-10, Präfix 756 |
| [[lyx_-_programmiersprache:units:validate:us_ssn|std.validate.us_ssn]] | US SSN (Social Security Number) — strukturell, bekannte Muster ausgeschlossen |
| [[lyx_-_programmiersprache:units:validate:ewc|std.validate.ewc]] | EWC/AVV-Abfallschlüssel — EU-Abfallkatalog, strukturell |
import std.validate.iban;
import std.validate.vin;
import std.io;
fn ValidatePayment(iban_str: pchar, card: pchar): bool {
var norm: pchar := IBANNormalize(iban_str);
if (IBANValidate(norm) != IBAN_OK) {
Print("Ungültige IBAN");
return false;
}
if (LuhnValidate(card) != LUHN_OK) {
Print("Ungültige Kartennummer");
return false;
}
return true;
}
-----
===== KI & Maschinelles Lernen =====
Drei Units für ML-Algorithmen, Worteinbettungen und probabilistische Logik. Alle vollständig in Lyx implementiert – kein Python, kein TensorFlow.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:ml|std.ml]] | ML-Kern: lineare Regression, logistische Regression, KNN, K-Means, Naive Bayes; Normalisierung (MinMax, Z-Score); Metriken (MSE, MAE, R², Accuracy) |
| [[lyx_-_programmiersprache:units:ml_full|std.ml_full]] | ML-Vollversion: alle std.ml-Algorithmen plus Entscheidungsbäume (Gini/Entropy/Chi²), Random Forest, Gradient Boosting, SVM (linear) |
| [[lyx_-_programmiersprache:units:fasttext|std.fasttext]] | FastText-Worteinbettungen: Skip-gram/CBOW-Training (SGD), ''FindNearest'', Analogien, Klassifikation, Save/Load |
| [[lyx_-_programmiersprache:units:qbool|std.qbool]] | Probabilistischer Boolean (''qbool''): Wahrscheinlichkeits-basierte Logik-Operationen, fuzzy Entscheidungen mit ''Observe()'', ''QBoolAnd'', ''QBoolOr'' |
→ Details mit vollständigen Beispielen: [[lyx_-_programmiersprache:guides:ml|ML – Detaildokumentation]]
import std.ml;
fn PredictHousePrice(sqm: f64, rooms: f64): f64 {
var X: [3][2]f64;
var y: [3]f64;
// Trainingsdaten befüllen …
var model := LinearRegression(X, y, 3);
var features: [2]f64;
features[0] := sqm;
features[1] := rooms;
return Predict(model, features);
}
-----
===== Utilities =====
Fünf allgemeine Hilfs-Units für häufig benötigte Querschnittsaufgaben.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:conv|std.conv]] | Zahlensystemkonvertierung: Hex, Binär, Oktal; Bitmanipulation (''SetBit'', ''ClearBit'', ''TestBit''); Endian-Umwandlung (''SwapU16'', ''SwapU32'', ''SwapU64'') |
| [[lyx_-_programmiersprache:units:country|std.country]] | ISO 3166-1-Länderdatenbank (249 Länder): Code ↔ Name, Währung, TLD, Telefon-Präfix, Region/Subregion |
| [[lyx_-_programmiersprache:units:uuid|std.uuid]] | UUID-Generierung v4 (zufällig, RFC 4122) und v7 (zeitbasiert, monoton sortierbar, RFC 9562); ''UuidToStr'', ''UuidFromStr'' |
| [[lyx_-_programmiersprache:units:systeminfo|std.systeminfo]] | Systeminformationen aus ''/proc'': CPU-Kerne, RAM-Gesamt/Frei, Load-Average (1/5/15 min), Uptime, Hostname |
| [[lyx_-_programmiersprache:units:units.lyx|std.units]] | Physikalische Einheitentypen (Meter, Kilogramm, Sekunde, …) und Konvertierungen (km/h ↔ m/s, °C ↔ °F, …) |
import std.uuid;
import std.conv;
import std.io;
fn GenerateToken(): pchar {
return UuidToStr(UuidV4()); // "550e8400-e29b-41d4-a716-446655440000"
}
fn PrintBitmask(val: int64) {
Print(IntToBin(val)); // "00101010"
Print(IntToHex(val)); // "2A"
}
-----
===== LyxVision (TUI-Framework) =====
LyxVision ist das integrierte Text-UI-Framework für terminalbasierte Anwendungen. Es ist nach dem Vorbild der klassischen Turbo Vision-Architektur aufgebaut: Ereignis-gesteuerte Widgets, Gruppen-/View-Hierarchie, modaler Dialog-Stack.
import lyxvision.app;
import lyxvision.tapplication;
import lyxvision.button;
import lyxvision.dialog;
fn main(): int64 {
var app := TApplicationCreate("Meine App");
var win := TWindowCreate(10, 5, 60, 20, "Hauptfenster");
var btn := TButtonCreate(5, 10, "OK", CMD_OK);
TGroupInsert(win, btn);
TApplicationRun(app);
TApplicationDestroy(app);
return 0;
}
^ Unit ^ Gruppe ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:lyxvision:main|lyxvision.main]] | Kern | Framework-Einstiegspunkt, Terminal-Helper-Funktionen |
| [[lyx_-_programmiersprache:units:lyxvision:app|lyxvision.app]] | Kern | ''TProgram'' – Anwendungsschleife, Ereignis-Dispatch |
| [[lyx_-_programmiersprache:units:lyxvision:tapplication|lyxvision.tapplication]] | Kern | ''TApplication'', ''TDesktop'', Menü- und Statusleiste |
| [[lyx_-_programmiersprache:units:lyxvision:drivers|lyxvision.drivers]] | Kern | Low-Level Terminal-Treiber (ANSI, xterm, Linux-Konsole) |
| [[lyx_-_programmiersprache:units:lyxvision:types|lyxvision.types]] | Typen | ''TEvent'', ''TPoint'', ''TRect'', Ereigniskonstanten (Maus, Tastatur, Befehl) |
| [[lyx_-_programmiersprache:units:lyxvision:consts|lyxvision.consts]] | Typen | Farben (16 Paare), View-Flags, State-Flags, Draw-Flags, Cursor-Stile |
| [[lyx_-_programmiersprache:units:lyxvision:view|lyxvision.view]] | Views | ''TView'' – Basis-Darstellungsobjekt; Draw, HandleEvent, SetState |
| [[lyx_-_programmiersprache:units:lyxvision:group|lyxvision.group]] | Views | ''TGroup'' – Container für Views; Insert, Delete, Broadcast |
| [[lyx_-_programmiersprache:units:lyxvision:window|lyxvision.window]] | Views | ''TWindow'' – Rahmenfenster mit Titelleiste, Zoom, Resize |
| [[lyx_-_programmiersprache:units:lyxvision:dialog|lyxvision.dialog]] | Views | ''TDialog'' – modaler Dialog; ExecView, Ergebnis-Handling |
| [[lyx_-_programmiersprache:units:lyxvision:frame|lyxvision.frame]] | Views | ''TFrame'' – Rahmenzeichnung (einfach/doppelt), Schatten |
| [[lyx_-_programmiersprache:units:lyxvision:button|lyxvision.button]] | Widgets | ''TButton'' – Schaltfläche mit Befehl, Tastaturkürzel, Focus |
| [[lyx_-_programmiersprache:units:lyxvision:cluster|lyxvision.cluster]] | Widgets | ''TCluster'' – Radio-Button- und Checkbox-Gruppe |
| [[lyx_-_programmiersprache:units:lyxvision:inputline|lyxvision.inputline]] | Widgets | ''TInputLine'' – Texteingabefeld mit Validierungs-Callback |
| [[lyx_-_programmiersprache:units:lyxvision:listview|lyxvision.listview]] | Widgets | ''TListView'' – scrollbare Listenansicht, selektierbare Einträge |
| [[lyx_-_programmiersprache:units:lyxvision:menu|lyxvision.menu]] | Widgets | ''TMenu'', ''TMenuBar'', ''TSubMenu'' – vollständiges Menüsystem |
| [[lyx_-_programmiersprache:units:lyxvision:statictext|lyxvision.statictext]] | Widgets | ''TStaticText'' – statische Textanzeige, mehrzeilig |
| [[lyx_-_programmiersprache:units:lyxvision:staticline|lyxvision.staticline]] | Widgets | ''TStaticLine'' – horizontale/vertikale Trennlinie |
| [[lyx_-_programmiersprache:units:lyxvision:terminal|lyxvision.terminal]] | Widgets | ''TTerminal'' – eingebetteter ANSI-Terminal-Emulator |
| [[lyx_-_programmiersprache:units:lyxvision:textdevice|lyxvision.textdevice]] | Widgets | ''TTextDevice'' – scrollbarer Textpuffer für Log-Ausgaben |
-----
===== Qt5-Bindings =====
Fünf Units für Desktop-GUI-Anwendungen mit Qt5. Die Bindings wrappen Qt5-C++-Funktionen über FFI und ermöglichen nativen OpenGL-Zugriff über EGL und GLX. Voraussetzung: Qt5 muss auf dem Zielsystem installiert sein.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:qt5_app|std.qt5_app]] | Qt5-Anwendungslebenszyklus: ''QApplication'' initialisieren, Event-Loop starten und beenden |
| [[lyx_-_programmiersprache:units:qt5_core|std.qt5_core]] | Qt5 Core-Modul: ''QString'', ''QVariant'', Signale/Slots-Infrastruktur |
| [[lyx_-_programmiersprache:units:qt5_egl|std.qt5_egl]] | Qt5 EGL-Surface-Bindings für Embedded-Linux und Wayland-Targets |
| [[lyx_-_programmiersprache:units:qt5_gl|std.qt5_gl]] | Qt5 OpenGL-Bindings: ''QOpenGLContext'', ''QOpenGLFunctions'', Shader |
| [[lyx_-_programmiersprache:units:qt5_glx|std.qt5_glx]] | Qt5 GLX-Bindings für X11-OpenGL (klassisches Desktop-Linux) |
import std.qt5_app;
import std.qt5_core;
fn main(): int64 {
var app: QApp := QAppCreate();
QAppSetTitle(app, "Lyx-Qt5-Fenster");
QAppRun(app);
QAppDestroy(app);
return 0;
}
-----
===== PDF-Bibliothek =====
25 Units für vollständige PDF-Erstellung und -Analyse direkt aus Lyx — ohne externe Bibliotheken. Erzeugt Standard-konforme PDFs (PDF 1.7) mit Text, Grafiken, TrueType-Schriften, Sonderfarben, Annotationen, Formularen, eingebetteten Dateien und PDF/A-Konformität. Interne Kompression über ''std.pdf.compress'' (zlib/DEFLATE).
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:pdf|std.pdf]] | Öffentliche PDF-API: ''PdfNew'', ''PdfSave'', ''PdfAddPage'' — Einstiegspunkt für alle PDF-Operationen |
| [[lyx_-_programmiersprache:units:pdf:objects|std.pdf.objects]] | Primitive für PDF-Buffer: Byte-Schreiboperationen, Objekt-Nummerierung |
| [[lyx_-_programmiersprache:units:pdf:builder|std.pdf.builder]] | Dokument-Builder: Cross-Reference-Tabelle, Trailer, Objekt-Flattening |
| [[lyx_-_programmiersprache:units:pdf:page|std.pdf.page]] | Seitenverwaltung: ''PdfAddPage'', ''PdfSetLandscape'', Seitengrößen (A4, Letter …) |
| [[lyx_-_programmiersprache:units:pdf:fonts|std.pdf.fonts]] | Standard-14-Schriftarten-Konstanten und AFM-Metrik-Tabellen |
| [[lyx_-_programmiersprache:units:pdf:ttfont|std.pdf.ttfont]] | TrueType-Schriften einbetten mit Unicode-Subsetting (Type0/CIDFontType2) |
| [[lyx_-_programmiersprache:units:pdf:graphics|std.pdf.graphics]] | Content-Stream: Text ausgeben, Pfade zeichnen, Farben setzen, Transformationen |
| [[lyx_-_programmiersprache:units:pdf:shading|std.pdf.shading]] | Farbverläufe: lineare und radiale Gradient-Füllungen |
| [[lyx_-_programmiersprache:units:pdf:spot|std.pdf.spot]] | Sonderfarben (Separation-Farbräume, PANTONE/CMYK) |
| [[lyx_-_programmiersprache:units:pdf:xobject|std.pdf.xobject]] | Form-XObjects: wiederverwendbare Grafik-Blöcke, die auf mehreren Seiten platziert werden können |
| [[lyx_-_programmiersprache:units:pdf:compress|std.pdf.compress]] | zlib/DEFLATE-Kompression für PDF-Streams (intern genutzt) |
| [[lyx_-_programmiersprache:units:pdf:image|std.pdf.image]] | Rasterbilder: ''PdfAddImage'' (JPEG/RGB), ''PdfDrawImage'' mit Positionierung |
| [[lyx_-_programmiersprache:units:pdf:meta|std.pdf.meta]] | Dokument-Metadaten: Titel, Autor, Thema, Schlüsselwörter, Erstellungsdatum |
| [[lyx_-_programmiersprache:units:pdf:xmp|std.pdf.xmp]] | XMP-Metadaten-Stream eingebettet im PDF-Katalog |
| [[lyx_-_programmiersprache:units:pdf:annot|std.pdf.annot]] | Annotationen: URI-Links, GoTo-Links, Text-Notizen |
| [[lyx_-_programmiersprache:units:pdf:forms|std.pdf.forms]] | AcroForms: interaktive PDF-Formularfelder (Text, Checkbox, Radio, Dropdown) |
| [[lyx_-_programmiersprache:units:pdf:reader|std.pdf.reader]] | PDF-Lesen: ''PdfOpen'', Seitenanzahl, Metadaten-Extraktion |
| [[lyx_-_programmiersprache:units:pdf:outline|std.pdf.outline]] | Outlines (Lesezeichen): ''PdfOutlineAdd'', verschachtelte Hierarchie |
| [[lyx_-_programmiersprache:units:pdf:pagelabels|std.pdf.pagelabels]] | Seitenbeschriftung: römisch, dezimal, alphabetisch |
| [[lyx_-_programmiersprache:units:pdf:transition|std.pdf.transition]] | Seitenübergänge: Dissolve, Wipe, Push, Split (Präsentation) |
| [[lyx_-_programmiersprache:units:pdf:viewprefs|std.pdf.viewprefs]] | Viewer-Einstellungen: Toolbar ausblenden, Vollbild, Öffnungs-Action |
| [[lyx_-_programmiersprache:units:pdf:namedest|std.pdf.namedest]] | Benannte Sprungziele für interne Links und Outline-Verweise |
| [[lyx_-_programmiersprache:units:pdf:attach|std.pdf.attach]] | Eingebettete Dateianhänge: ''PdfAttachFile'' |
| [[lyx_-_programmiersprache:units:pdf:layer|std.pdf.layer]] | Optional-Content-Groups (Layer/OCG): sichtbare/ausblendbare Ebenen |
| [[lyx_-_programmiersprache:units:pdf:pdfa|std.pdf.pdfa]] | PDF/A-Konformität: OutputIntent, sRGB-ICC-Profil, XMP pdfaid (Langzeitarchivierung) |
import std.pdf;
import std.pdf.graphics;
import std.pdf.meta;
fn CreateReport(): void {
var doc: Pdf := PdfNew();
PdfSetTitle(doc, "Lyx Report 2026");
PdfSetAuthor(doc, "Andreas Röne");
var page: PdfPage := PdfAddPage(doc);
PdfSetFont(page, "Helvetica", 14);
PdfDrawText(page, 72.0, 720.0, "Lyx PDF-Bibliothek — Beispiel");
PdfSave(doc, "report.pdf");
}
-----
===== LFD-Binärformat =====
Zwei Units für das Lyx File Data-Format (LFD) — ein strukturiertes Binärformat für effizienten Datenaustausch zwischen Lyx-Programmen.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:lfd_parser|std.lfd_parser]] | LFD-Binärdateien lesen: ''LfdOpen'', ''LfdReadRecord'', Feld-Iteration |
| [[lyx_-_programmiersprache:units:lfd_factory|std.lfd_factory]] | LFD-Binärdateien schreiben: ''LfdCreate'', ''LfdWriteRecord'', ''LfdClose'' |
-----
===== SVG-Bibliothek =====
12 Units für programmatische Vektorgrafik-Erzeugung: Grundformen, Pfade, Text, Farbverläufe, Filter, Animationen und Einlesen vorhandener SVG-Dateien. Erzeugt standard-konforme SVG 1.1-Dateien ohne externe Abhängigkeiten.
→ Details und Architektur: [[lyx_-_programmiersprache:units:svg|std.svg Übersicht]]
import std.svg;
var svg: Svg := SvgNew(800.0, 600.0);
SvgCircle(svg, 400.0, 300.0, 100.0, "fill:royalblue;stroke:navy;stroke-width:2");
SvgTextAt(svg, 400.0, 300.0, "Hallo SVG", "font-size:24;text-anchor:middle;fill:white");
SvgSave(svg, "ausgabe.svg");
SvgFree(svg);
^ Unit ^ Gruppe ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:svg|std.svg]] | API | Öffentliche Einstiegs-API: SvgNew, SvgSave, SvgFree, SvgToString |
| [[lyx_-_programmiersprache:units:svg:builder|std.svg.builder]] | Infrastruktur | Dokumentlebenszyklus, Gruppen (''''), Viewport, viewBox |
| [[lyx_-_programmiersprache:units:svg:xml|std.svg.xml]] | Infrastruktur | Interner XML-Schreiber: Puffer, Zahlenformatierung, Escaping |
| [[lyx_-_programmiersprache:units:svg:style|std.svg.style]] | Querschnitt | Fill, Stroke, Opacity, Transforms, Dash-Muster, Farb-Utilities |
| [[lyx_-_programmiersprache:units:svg:elements|std.svg.elements]] | Inhalt | Grundformen: rect, circle, ellipse, line, polyline, polygon |
| [[lyx_-_programmiersprache:units:svg:path|std.svg.path]] | Inhalt | Pfad-Builder: moveTo, lineTo, Bezier-Kurven, Bögen, close |
| [[lyx_-_programmiersprache:units:svg:text|std.svg.text]] | Inhalt | Text: SvgTextAt, tspan, Text auf Pfad, Rotation, Font-Styling |
| [[lyx_-_programmiersprache:units:svg:defs|std.svg.defs]] | Inhalt | Definitionen: Farbverläufe, Muster, Symbole, Marker, Clips |
| [[lyx_-_programmiersprache:units:svg:filter|std.svg.filter]] | Inhalt | Filter: Gaussian Blur, Schlagschatten, Graustufen, feComposite |
| [[lyx_-_programmiersprache:units:svg:image|std.svg.image]] | Inhalt | Bilder: JPEG/PNG einbetten, Base64-URI, RGB→PNG-Konvertierung |
| [[lyx_-_programmiersprache:units:svg:anim|std.svg.anim]] | Inhalt | SMIL-Animation: animate, animateTransform, Keyframes, animateMotion |
| [[lyx_-_programmiersprache:units:svg:parser|std.svg.parser]] | Lesen | SVG-Reader: SvgOpen, DOM-Traversierung, SvgAttrStr, SvgFindById |
-----
===== Hardware — Bluetooth =====
Neun Units für native Bluetooth-Kommunikation auf Linux. Die Units decken den vollständigen Stack ab: von rohen ''AF_BLUETOOTH''-Sockets über BlueZ-D-Bus-Kontrolle bis zu vollständigen GATT-Client-/Server-Implementierungen für Bluetooth Low Energy (BLE).
→ Details: [[lyx_-_programmiersprache:units:hardware:bluetooth|std.hardware.bluetooth Übersicht]]
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:hardware:bluetooth|std.hardware.bluetooth]] | Low-Level Bluetooth-Socket-Syscalls (''AF_BLUETOOTH'') |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_types|std.hardware.bluetooth_types]] | Bluetooth-Adress-, Socket- und Protokolltyp-Definitionen |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_dbus|std.hardware.bluetooth_dbus]] | BlueZ D-Bus Steuerungsebene: Adapter- und Geräte-Management |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_rfcomm|std.hardware.bluetooth_rfcomm]] | RFCOMM (Classic Bluetooth): Client und Server |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_l2cap|std.hardware.bluetooth_l2cap]] | BLE L2CAP und ATT-Protokollschicht |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_gattc|std.hardware.bluetooth_gattc]] | GATT-Client: Service-Discovery, Characteristic Read/Write |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_gatts|std.hardware.bluetooth_gatts]] | GATT-Server: eigene BLE-Services definieren und anbieten |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_ext|std.hardware.bluetooth_ext]] | BLE Scanner, Advertising und Mesh-Erweiterungen |
| [[lyx_-_programmiersprache:units:hardware:bluetooth_ai|std.hardware.bluetooth_ai]] | KI-native, typsichere Bluetooth-Profile als Compiler-Typen |
import std.hardware.bluetooth_gattc;
import std.hardware.bluetooth_types;
fn ReadHeartRate(target: BtAddr): int64 {
var dev := GattcConnect(target);
var services := GattcDiscoverServices(dev);
var val := GattcReadChar(services[0], HEART_RATE_CHAR_UUID);
GattcDisconnect(dev);
return val;
}
-----
===== Hardware — USB =====
Dreizehn Units für native USB-Host-Kommunikation auf Linux. Alle Transfers (Control, Bulk, Interrupt, Isochronous) direkt via ''usbdevfs''-ioctls — kein libusb. Typsichere Endpoint-Wrapper und ein URB-Pool für überlappende Interrupt-Streams.
→ Details: [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb Übersicht]]
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_syscalls]] | Low-Level Syscall-Wrapper: open/read/write/ioctl/close/lseek/getdents64/poll |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_util]] | Dirent64-Parser, UsbIsNumeric, UsbParseNum, UsbBuildPath |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_types]] | Descriptor-Konstanten, Lyx-Structs (UsbDevice/Interface/Endpoint), Accessoren |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_parse]] | UsbAllocDevice, UsbParseConfiguration — Descriptor-Strom → Baum |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_discovery]] | UsbFindDevice, UsbFindDevicePath — VID/PID-Scan über /dev/bus/usb/ |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_control]] | Control-Transfers, UsbGetDeviceDescriptor, UsbClaimInterface, UsbReleaseInterface |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_bulk]] | UsbBulkWrite, UsbBulkRead — synchrone Bulk-Transfers |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_interrupt]] | URB allokieren/einreichen/warten — asynchrone Interrupt-Transfers |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_iso]] | ISO-URBs mit Paket-Deskriptoren — UsbSubmitIsoRead, UsbReapIsoUrb |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_endpoint_types]] | Typsichere Wrapper: UsbBulkOutEndpoint (nur Write), UsbBulkInEndpoint (nur Read) |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_endpoint_bind]] | Endpoint-Registry: Adressen per Schlüssel binden, UsbEpWrite, UsbEpRead |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_ifc_mgr]] | Idempotenter Claim-Manager: UsbIfcAcquire, UsbIfcRelease |
| [[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_urb_pool]] | URB-Pool (4 Slots): UsbUrbPoolInit, UsbUrbPoolPoll, UsbUrbPoolResubmit |
import std.hardware.usb_discovery;
import std.hardware.usb_parse;
import std.hardware.usb_control;
import std.hardware.usb_bulk;
fn OpenDevice(): int64 {
var dev: int64 := UsbAllocDevice();
if (UsbFindDevice(0x1234, 0x5678, dev) != USB_FIND_OK) { return -1; }
var fd: int64 := peek64(dev + 48); // dev.handle
UsbClaimInterface(fd, 0);
return fd;
}
-----
===== Hardware — GPIO =====
Acht Units für native GPIO-Steuerung auf dem Raspberry Pi 4 (BCM2711/ARM64). Zwei komplementäre Zugriffsmodi: MMIO-Direktzugriff (kein Syscall nach der Initialisierung — ideal für Software-PWM und Bit-Bang-Protokolle) und Linux GPIO-v2 ioctl (Multi-Pin atomar, Edge-Detection, Consumer-Labels). Typsichere Pin-Wrapper verhindern zur Compile-Zeit, dass ein Output-Pin gelesen oder ein Input-Pin geschrieben wird.
→ Details: [[lyx_-_programmiersprache:units:hardware:gpio|std.hardware.gpio Übersicht]]
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:hardware:gpio_barriers|std.hardware.gpio_barriers]] | ARM64 Memory-/Instruction-Barrier: GpioMemBarrier (DMB SY), GpioInstBarrier (ISB SY) |
| [[lyx_-_programmiersprache:units:hardware:gpio_syscalls|std.hardware.gpio_syscalls]] | Low-Level Syscall-Wrapper: GpioOpen, GpioIoctl, GpioPoll, GpioMmap, GpioMunmap |
| [[lyx_-_programmiersprache:units:hardware:gpio_util|std.hardware.gpio_util]] | Hilfsfunktionen: GpioDelayMicroseconds (±1–2 µs), GpioCopyStringToBuf |
| [[lyx_-_programmiersprache:units:hardware:rpi4|std.hardware.rpi4]] | BCM2711-Hardware-Konstanten: Register-Offsets, Pin-Modi, Pull-Codes (nur Konstanten) |
| [[lyx_-_programmiersprache:units:hardware:gpio_mmio|std.hardware.gpio_mmio]] | MMIO-Direktzugriff: GpioInit, GpioSetPinMode, GpioWritePin, GpioReadPin, GpioSetPullMode |
| [[lyx_-_programmiersprache:units:hardware:gpio_ioctl|std.hardware.gpio_ioctl]] | Linux GPIO-v2 ioctl: GpioGetChipInfo, GpioRequestLines, GpioSetLineValues, GpioGetLineValues |
| [[lyx_-_programmiersprache:units:hardware:gpio_pin|std.hardware.gpio_pin]] | Typsichere Wrapper: GpioOutputPin* (nur Write), GpioInputPin* (nur Read) |
| [[lyx_-_programmiersprache:units:hardware:gpio_ext|std.hardware.gpio_ext]] | Erweiterungen: GpioSetAltMode (ALT0–ALT5), GpioWaitForEdge, GpioSoftPWM |
import std.hardware.gpio_mmio;
import std.hardware.gpio_pin;
import std.hardware.gpio_ext;
fn main(): int64 {
var ctx := GpioCtxAlloc();
GpioInit(ctx);
// LED an Pin 18 mit typsicherem Wrapper
var led := GpioOutputPinAlloc(ctx, 18);
GpioOutputPinInit(led, GPIO_PULL_NONE);
// Taster an Pin 17 mit Pull-Up
var btn := GpioInputPinAlloc(ctx, 17);
GpioInputPinInit(btn, GPIO_PULL_UP);
// Software-PWM: LED dimmen (1 kHz, 50 % Duty, 2 Sekunden)
GpioSoftPWM(ctx, 18, 1000, 50, 2000);
GpioOutputPinFree(led);
GpioInputPinFree(btn);
GpioClose(ctx);
GpioCtxFree(ctx);
return 0;
}
-----
===== Android =====
16 Units für native Android-Entwicklung über das NDK (Native Development Kit). Ermöglichen vollständige Android-Apps in Lyx ohne Java-Schicht: JNI-Typen, OpenGL ES 2.0, Sensoren, Asset-Manager, APK-Bau und Logcat-Logging.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:android:apk_builder|std.android.apk_builder]] | APK-Builder: PKZIP-Archive für Android-Pakete zusammenstellen |
| [[lyx_-_programmiersprache:units:android:app_glue|std.android.app_glue]] | ''NativeActivity''-Worker-Thread-Glue-Schicht (android_app-Struktur) |
| [[lyx_-_programmiersprache:units:android:asset|std.android.asset]] | NDK-Asset-Manager: Typen und Konstanten für ''AAssetManager'' |
| [[lyx_-_programmiersprache:units:android:gles2|std.android.gles2]] | OpenGL ES 2.0 Core-Bindings: Shader, Texturen, Framebuffer |
| [[lyx_-_programmiersprache:units:android:input|std.android.input]] | NDK-Eingabe-Events: Typen und Konstanten für ''AInputEvent'' |
| [[lyx_-_programmiersprache:units:android:ioctl|std.android.ioctl]] | ioctl-Nummernkatalog für ASHMEM, ALSA und V4L2 |
| [[lyx_-_programmiersprache:units:android:jni|std.android.jni]] | JNI 1.6 Typ-Aliases: ''JNIEnv'', ''JavaVM'', ''jclass'', ''jobject'' |
| [[lyx_-_programmiersprache:units:android:log|std.android.log]] | Logcat-Logging: Ausgabe auf stderr/fd 2 mit Priority-Level |
| [[lyx_-_programmiersprache:units:android:looper|std.android.looper]] | ''ALooper''-Ereignis-Dispatch-Primitiv für native Event-Loops |
| [[lyx_-_programmiersprache:units:android:manifest_gen|std.android.manifest_gen]] | ''AndroidManifest.xml''-Generator für native Activities |
| [[lyx_-_programmiersprache:units:android:native_activity|std.android.native_activity]] | ''ANativeActivity''-Struct und Callback-Tabelle |
| [[lyx_-_programmiersprache:units:android:native_window|std.android.native_window]] | NDK-Native-Window: Typen und Pixelformat-Konstanten |
| [[lyx_-_programmiersprache:units:android:random|std.android.random]] | Kryptografische Zufallszahlen via ''/dev/urandom'' |
| [[lyx_-_programmiersprache:units:android:restrictions|std.android.restrictions]] | Katalog der unter SELinux/Bionic gesperrten Syscalls |
| [[lyx_-_programmiersprache:units:android:sensor|std.android.sensor]] | NDK-Sensor-Typen: Beschleunigungsmesser, Gyroskop, Magnetometer |
| [[lyx_-_programmiersprache:units:android:zip_writer|std.android.zip_writer]] | PKZIP-Writer für gespeicherte Einträge (Grundlage für APK-Build) |
import std.android.jni;
import std.android.log;
import std.android.gles2;
fn Java_com_example_Main_init(env: JNIEnv, obj: jobject): void {
AndroidLog(ANDROID_LOG_INFO, "MyApp", "Native init gestartet");
GLViewport(0, 0, 1920, 1080);
GLClearColor(0.1, 0.1, 0.1, 1.0);
}
===== Cloud — AWS =====
13 Units für AWS-Dienste und interne Schichten. Vollständig in Lyx implementiert — kein AWS SDK. Alle Requests werden mit AWS Signature Version 4 (SigV4) signiert.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.aws]] | Alle AWS-Units auf einer Übersichtsseite |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]] | S3: Buckets, Upload/Download/Range, Multipart, Pagination, Presigned URLs (GET/PUT/DELETE/HEAD); S3ConnectR2 + S3ConnectMinio (54 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.ec2]] | EC2: Instanzen, AMIs, Key Pairs, Security Groups, VPCs, Elastic IPs, EBS (32 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.dynamodb]] | DynamoDB: Table-CRUD, PutItem, GetItem, Query, Scan, UpdateItem (20 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.lambda]] | Lambda: Funktionen erstellen, deployen, aufrufen, Event-Source-Mappings (15 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.iam]] | IAM+STS: Users, Roles, Policies, Access Keys, AssumeRole (23 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.sqs]] | SQS: Standard- und FIFO-Queues, Send, Receive, Delete, Batch (17 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.sns]] | SNS: Topics, Subscribe, Publish, SMS, Platform Endpoints (16 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.cloudwatch]] | CloudWatch: Metriken, Alarme, Logs (CWClient + CWLogsClient, 21 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.secrets]] | Secrets Manager + SSM Parameter Store: Secret-CRUD, Rotation (23 Fn) |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.aws.core]] | Credentials (Chain/Static/Env/File), Endpoint-Auflösung, AWSServiceConfig |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.aws.sigv4]] | SigV4-Signatur: Header-Auth und Presigned Query Strings |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.aws.transport]] | HTTP-Transport mit Retry, JSON/XML/REST/S3-Request-Helpers |
| [[lyx_-_programmiersprache:units:cloud:aws|std.cloud.aws.xml]] | Leichtgewichtiger XML-Parser und Query-String-Builder für EC2/S3 |
import std.cloud.aws.core;
import std.cloud.s3;
fn main(): int64 {
var creds: AWSCreds := AWSCredentialsDefault();
var s3: S3Client := S3Connect(creds, "eu-central-1"c);
S3PutObjectFile(s3, "mein-bucket"c, "bericht.pdf"c, "/tmp/bericht.pdf"c, "application/pdf"c);
S3Close(s3);
return 0;
}
-----
===== Cloud — DigitalOcean =====
13 Units für die DigitalOcean API v2. Authentifizierung über Bearer-Token (''DOCredentials'').
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do]] | Alle DO-Units auf einer Übersichtsseite |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.droplets]] | VMs: Erstellen, Starten, Stoppen, IP ermitteln, Warten, SSH-Keys (43 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.volumes]] | Block-Storage: Anlegen, Anhängen, Snapshots (21 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.spaces]] | Objekt-Speicher (S3-kompatibel): Buckets, Upload/Download (17 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.databases]] | Managed Databases: PostgreSQL/MySQL/Redis, Users, Pools, Firewall (42 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.kubernetes]] | DOKS: Cluster, Node-Pools, Kubeconfig (22 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.apps]] | App Platform: Deploy, Deployments, Logs (20 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.functions]] | Serverless Functions: Namespaces, Invoke, Logs (17 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.networking]] | DNS, Load Balancer, Floating IPs, VPCs, Firewalls (45 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.monitoring]] | Alert Policies, CPU/Bandbreite/Disk/Memory-Metriken (19 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.registry]] | Container Registry: Repositories, Tags, GC, Docker-Credentials (17 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.credentials]] | Bearer-Token: Env, Datei, doctl-Config, Token-Validierung (16 Items) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.transport]] | HTTP-Client für DO API v2 (DOGet/Post/Put/Patch/Delete) |
| [[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.core]] | Initialisierung und Version |
import std.cloud.do.credentials;
import std.cloud.do.droplets;
fn main(): int64 {
var creds: DOCredentials := DOCredentialsFromEnv();
var keys: array := [12345678];
var d: DODroplet := DropletCreateSimple(creds, "web-01"c, "fra1"c,
"s-2vcpu-2gb"c, "ubuntu-22-04-x64"c,
keys as int64, 1);
d = DropletWait(creds, d.id, "active"c);
var ip: int64 := DropletGetIP(creds, d.id);
Print("IP: "c); Print(ip as pchar); PrintLn(""c);
DODropletFree(d);
DOCredentialsFree(creds);
return 0;
}
===== Cloud — Cloudflare =====
16 Units für die Cloudflare API v4. Authentifizierung über API-Token (''CFCredentials''). CFResponse unterscheidet sich von AWS: ''success''-Feld (1/0) statt HTTP-Statuscode.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf]] | Alle CF-Units auf einer Übersichtsseite |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.zones]] | Domains: Anlegen, Pause/Unpause, SSL-Settings, Development Mode (29 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.dns]] | DNS-Records CRUD + Upsert, Suche nach Typ/Name (23 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.workers]] | Workers deployen, Routes, Secrets, Crons, Tail, Subdomain (27 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.kv]] | Workers KV: Get/Put/Delete, TTL, Bulk, paginiertes Listing (19 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.r2]] | R2 Objekt-Speicher: Upload/Download, Multipart, Presigned URLs, Custom Domains (27 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.d1]] | D1 SQLite: Create/Query/Exec/ExecScript (24 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.cache]] | Cache-Purge (All/Files/Tags/Prefixes), Page Rules, Cache-Rules, Transform Rules (31 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.waf]] | Firewall-Rules, IP/Country-Sperren, Rate Limiting (32 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.lb]] | Load Balancer: Health Checks, Origin Pools, Load Balancer (20 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.pages]] | Pages: Projekte, Deployments, Custom Domains, Env-Vars (23 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.tunnel]] | Cloudflare Tunnel: erstellen, Token, Ingress-Regeln (22 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.email]] | Email Routing: Regeln, Worker-Weiterleitung, DNS-Verifikation (19 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.analytics]] | Zone-Analytics, GraphQL, Logpush, Web Analytics (14 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.credentials]] | API-Token / Legacy-Key, Env, Config-Datei (11 Items) |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.transport]] | CFClient, CFResponse, HTTP-Helpers |
| [[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.core]] | Interne JSON/Pfad-Builder (kein direkter Import nötig) |
import std.cloud.cf.credentials;
import std.cloud.cf.transport;
import std.cloud.cf.dns;
fn main(): int64 {
var creds: CFCredentials := CFCredentialsFromEnv();
var c: CFClient := CFClientNew(creds);
// A-Record anlegen oder aktualisieren
var r: CFDNSRecord := DNSRecordUpsert(c, "abc123"c, "A"c,
"api"c, "1.2.3.4"c, 1, 1);
CFDNSRecordFree(r);
CFClientFree(c);
CFCredentialsFree(creds);
return 0;
}
-----
===== Cloud — GCP =====
11 Units für die Google Cloud Platform API. Authentifizierung über Application Default Credentials (''GCPCredentials''): Service Account (JWT RS256), Authorized User (OAuth 2.0 Refresh Token) oder GCE-Metadata-Server. Kein GCP SDK.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp]] | Alle GCP-Units auf einer Übersichtsseite |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.storage]] | Cloud Storage (GCS): Buckets, Upload/Download, Metadaten, Listing (13 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.compute]] | Compute Engine (GCE): Instanzen, asynchrone Operationen via GCEOperation, Standard-Zone europe-west1-b (10 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.firestore]] | Cloud Firestore: FSDoc (max. 64 Felder), CRUD, Listing (20 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.pubsub]] | Cloud Pub/Sub: Topics, Subscriptions, Publish (base64url), Pull, Acknowledge (10 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.functions]] | Cloud Functions v2 + Cloud Run v2: Deploy, Invoke, Service-Listing (12 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.logging]] | Cloud Logging + Cloud Monitoring: Text/JSON-Logs, Custom Metrics, Alert Policies (10 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.secrets]] | Secret Manager + IAM: Secret-CRUD, Versionierung, Service Accounts, IAM-Policies (15 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.credentials]] | Application Default Credentials: Credential Chain, Token-Cache, GCE-Erkennung (8 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.jwt]] | JWT RS256 für Service Accounts: GCPServiceAccount, GCPBuildJWT, Base64url (5 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.oauth]] | Access-Token-Verwaltung: GCPToken, auto-Refresh (Ablauf − 60 s) (5 Fn) |
| [[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.transport]] | HTTP-Transport: GCPClient, GCPResponse, auto-Retry auf 429/5xx, Backoff (10 Fn) |
import std.cloud.gcp.credentials;
import std.cloud.gcp.storage;
fn main(): int64 {
// Credential Chain: GOOGLE_APPLICATION_CREDENTIALS → ADC → GCE-Metadata
var creds: GCPCredentials := GCPCredentialsDefault(
"https://www.googleapis.com/auth/devstorage.read_write"c);
var gcs: GCSConn := GCSConnect(addr creds, "mein-projekt"c);
var data: pchar := "Hallo GCS"c;
GCSUpload(gcs, "mein-bucket"c, "hello.txt"c, data as int64, 9, "text/plain"c);
GCSDisconnect(gcs);
GCPCredentialsFree(creds);
return 0;
}
===== KassenSichV =====
6 Units für gesetzeskonforme TSE-Anbindung nach **KassenSichV**, **BSI TR-03153** und **DSFinV-K 2.3**. Vollständige Kapselung des Signierablaufs: Kassensoftware übergibt Belegdaten, erhält alle Pflichtangaben für den Bondruck — einschließlich QR-Code-String nach BSI TR-03153 Anhang A.
→ Details und Provider-Konzept: [[lyx_-_programmiersprache:units:kassensichv|kassensichv Übersicht]]
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:kassensichv:types|kassensichv.types]] | ''BelegDaten'', ''SigErgebnis'', Prozesstyp-Konstanten (''PROZESSTYP_KASSENBELEG'', …) |
| [[lyx_-_programmiersprache:units:kassensichv:manager|kassensichv.manager]] | Haupteinstiegspunkt: ''TseProcessBeleg'', ''TseOpenBeleg'', ''TseCloseBeleg'', ''TseExportAuditData'' |
| [[lyx_-_programmiersprache:units:kassensichv:mock|kassensichv.mock]] | Test-Provider ohne TSE-Hardware; Fehlersimulation (Timeout, Connection) |
| [[lyx_-_programmiersprache:units:kassensichv:rest|kassensichv.rest]] | Cloud-TSE via HTTPS/REST (Fiskaly, Deutsche Fiskal); TLS 1.2+, Retry mit Backoff |
| [[lyx_-_programmiersprache:units:kassensichv:file|kassensichv.file]] | USB-TSE via Dateisystem (Swissbit, Epson); Poll alle 100 ms, Timeout konfigurierbar |
| [[lyx_-_programmiersprache:units:kassensichv:exceptions|kassensichv.exceptions]] | ''TseError''-Typ mit Code (400–503) und deutschsprachiger Fehlermeldung |
import kassensichv.types;
import kassensichv.mock;
import kassensichv.manager;
fn DruckKassenbon(): void {
var mgr: int64 := TseMockNew(); // für Tests; TseRestNew/TseFileNew für echte TSE
var beleg: BelegDaten;
beleg.prozessTyp := PROZESSTYP_KASSENBELEG;
beleg.kassenNr := "KASSE-001"c;
beleg.prozessDaten := "Kaffee;2.50_0.00_0.00_0.00_0.00"c;
beleg.umsatz := 250; // Eurocent
var sig: int64 := TseProcessBeleg(mgr, addr beleg);
var s: SigErgebnis := (sig as *SigErgebnis)^;
// Pflichtdaten auf Bon drucken
PrintLn(s.tseSerial as pchar); // TSE-Seriennummer
PrintLn(IntToStr(s.sigZaehler)c); // Signaturzähler
PrintLn(s.qrCode as pchar); // QR-Code-String BSI TR-03153
SigErgebnisFree(sig);
TseManagerFree(mgr);
}
-----
===== Blockchain =====
Zwei Units für eine vollständige Proof-of-Work-Blockchain in Lyx: Transaktionen, Blöcke, kontobasierter Ledger, Mining, Kettenvalidierung und TCP-P2P-Netzwerk.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:blockchain|std.blockchain]] | Serializer (Big-Endian, Merkle-Root), Transaktions- und Block-Modelle, immutable Ledger (1024-Bucket-Hashtabelle), PoW-Konsens (Mining, Schwierigkeitsanpassung, Kettenvalidierung) |
| [[lyx_-_programmiersprache:units:blockchain:p2p|std.blockchain.p2p]] | TCP P2P-Netzwerk: Knoten, Peer-Verbindungen, Broadcast TX/Block, Nachrichten-Deserializer |
import std.blockchain;
import std.blockchain.p2p;
import std.crypto.ecc;
import std.alloc;
fn main(): int64 {
var bc: int64 := BLBlockchainNew(1, 50000000, 100);
// Miner-Adresse aus Public Key ableiten
var priv: int64 := alloc(BL_PRIVKEY_LEN);
var pub: int64 := alloc(BL_PUBKEY_LEN);
ECCGenerateKeyPair(priv, pub);
var addr: int64 := alloc(BL_ADDR_LEN);
SHA256(pub, BL_PUBKEY_LEN, addr);
// Block minen — erster Block nach Genesis
BLMinePendingTransactions(bc, addr);
// P2P-Knoten starten
var node: int64 := BLP2PNodeNew(bc, 9000);
BLP2PNodeStart(node);
// ... TX hinzufügen, weitere Blöcke minen, Peers verbinden ...
BLP2PNodeFree(node);
BLBlockchainFree(bc);
free(priv, BL_PRIVKEY_LEN);
free(pub, BL_PUBKEY_LEN);
free(addr, BL_ADDR_LEN);
return 0;
}
-----
===== CPU & SIMD =====
Zwei Units als Grundlage für SIMD-beschleunigtes Rechnen (WP-GPU-02). Sie erkennen zur Laufzeit die CPU-Fähigkeiten und stellen 16-Byte-ausgerichtete f32-Arrays bereit. GPU-Units (''std.gpu.*'') sind geplant, aber noch nicht implementiert.
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:cpu:features|std.cpu.features]] | CPU-Feature-Erkennung via ''/proc/cpuinfo'': SSE2, SSE4.1, AVX2; Bitmask-Konstanten, gecachtes Ergebnis; ''CpuFeatureDetect'', ''CpuHasSSE2/SSE41/AVX2'' |
| [[lyx_-_programmiersprache:units:cpu:dispatch|std.cpu.dispatch]] | Runtime-SIMD-Dispatch (AVX2 > SSE2 > Scalar); 16-Byte-ausgerichtete f32-Arrays via mmap; ''SimdAlloc'', ''SimdAdd/Sub/Mul/Div'', ''SimdGet/Set/Len'', ''CpuDispatchLevel'' |
import std.cpu.dispatch;
import std.io;
fn main(): int64 {
// Dispatch-Level abfragen
var lvl: int64 := CpuDispatchLevel();
if (lvl == CPU_DISPATCH_AVX2) {
PrintLn("AVX2 aktiv");
} else if (lvl == CPU_DISPATCH_SSE2) {
PrintLn("SSE2 aktiv");
} else {
PrintLn("Scalar-Fallback");
}
// f32-Arrays anlegen (Bits: 1.0 = 0x3F800000, 2.0 = 0x40000000)
var a: int64 := SimdAlloc(4);
var b: int64 := SimdAlloc(4);
var i: int64 := 0;
while (i < 4) {
SimdSet(a, i, 0x3F800000); // 1.0
SimdSet(b, i, 0x40000000); // 2.0
i := i + 1;
}
var result: int64 := SimdAdd(a, b);
PrintLn(IntToStr(SimdLen(result)) + " Elemente berechnet");
return 0;
}
> **Hinweis:** Der Scalar-Fallback in ''std.cpu.dispatch'' ist ein Placeholder (WP-GPU-02 in Entwicklung). Echte SIMD-Instruktionen (ADDPS/VADDPS) werden vom Compiler-Codegen emittiert, wenn der Compiler f32-Ausdrücke auf SIMD-Arrays optimiert.
-----
===== Bildverarbeitung =====
Neun Units zum Laden und Verarbeiten von Rasterbildern. Alle Formate werden auf ein einheitliches internes Format normalisiert: **RGBA, 4 Kanäle, 8 Bit/Kanal**, zeilenweise top-down. Der ''GrfImage''-Struct (56 Bytes) ist der gemeinsame Träger.
→ Details: [[lyx_-_programmiersprache:units:image|std.image Übersicht]]
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:image:core|std.image.core]] | ''GrfImage''-Struct (GRF-00): Allokation, Pixel-Lesen/Schreiben, Füllen, Format-Erkennung via Magic-Bytes |
| [[lyx_-_programmiersprache:units:image:image|std.image.image]] | Unified Facade (GRF-08): ''ImageDecode'' (Datei), ''ImageDecodeFromMem'' (Puffer), ''ImageFree'', ''ImageGetWidth/Height/Channels'', ''ImagePixelAt'' |
| ''std.image.bmp'' | BMP-Decoder (GRF-01) |
| ''std.image.png'' | PNG-Decoder (GRF-02) |
| ''std.image.jpeg'' | JPEG-Decoder (GRF-03) |
| ''std.image.gif'' | GIF-Decoder (GRF-04) |
| ''std.image.tiff'' | TIFF-Decoder (GRF-05), Little-Endian und Big-Endian |
| ''std.image.webp'' | WebP-Decoder (GRF-06) |
| ''std.image.avif'' | AVIF-Decoder (GRF-07) |
import std.image.image;
import std.image.core;
import std.alloc;
fn main(): int64 {
var img: int64 := GrfImageAlloc(0, 0);
if (ImageDecode("foto.jpg"c as int64, 0, img) == 0) { return 1; }
var w: int64 := ImageGetWidth(img);
var h: int64 := ImageGetHeight(img);
var px: int64 := ImagePixelAt(img, w / 2, h / 2); // Mittelpixel
var r: int64 := (px >> 24) & 255; // Rotanteil
ImageFree(img);
return 0;
}
-----
===== Office-Dokumente =====
Vier Units für die Erstellung von ODF-konformen Dokumenten. ''std.office.odt'' erzeugt Textdokumente (.odt), ''std.office.ods'' Tabellenkalkulationen (.ods). Beide nutzen intern ''std.zip'' für das ZIP-Archiv-Format von ODF.
→ Details: [[lyx_-_programmiersprache:units:office|std.office Übersicht]]
^ Unit ^ Beschreibung ^
| ''std.office.odf_doc'' | ''OdfDocument''-Klasse (OFF-03): Initialisierung, Puffer-Verwaltung, Style-Deduplizierung, ''SaveToFile'' |
| ''std.office.odt'' | ODT-Text-Writer (OFF-04): ''OdtAddParagraph'', ''OdtAddHeading'', ''OdtAddParagraphStyled'', ''OdtAddHorizontalRule'', ''OdtAddLineBreak'' |
| ''std.office.ods'' | ODS-Tabellen-Writer (OFF-05): ''OdsAddSheet'', ''OdsSetCell'', ''OdsSetCellInt'', ''OdsSetCellFloat'', ''OdsFlushSheet'' |
| ''std.office.odf_xml'' | XML-Templates intern (kein direkter Import nötig) |
import std.office.odf_doc;
import std.office.odt;
fn main(): int64 {
var doc: OdfDocument;
doc.Init(ODF_TYPE_TEXT);
OdtAddHeading(doc, "Bericht Q2 2026", 1);
OdtAddParagraphStyled(doc, "Wichtig: Bitte lesen!", 1, 0); // fett
OdtAddParagraph(doc, "Alles in Ordnung.");
doc.SaveToFile("bericht.odt"c);
doc.Close();
return 0;
}
-----
===== Video =====
Drei Units für Video-Container-Metadaten. Unterstützte Container: **AVI** und **MP4/ISOBMFF**. Codec-Erkennung für H.264, H.265, AV1, VP8, VP9, MPEG-4 Part 2 und MJPEG. AVI mit MJPEG-Codec unterstützt zusätzlich Frame-Extraktion und direkte Dekodierung über ''std.image.jpeg''.
→ Details: [[lyx_-_programmiersprache:units:video|std.video Übersicht]]
^ Unit ^ Beschreibung ^
| ''std.video.core'' | ''VidMeta''-Struct (VID-00, 64 Bytes): Offsets für Breite/Höhe/Dauer/FPS/Frames/Format/Codec; Format- und Codec-Konstanten; ''VidDetectFormat'' |
| ''std.video.avi'' | AVI-Reader (VID-01): ''AviMeta'', ''AviMetaFile'', ''AviGetFrameCount'', ''AviGetFrameOffset'', ''AviExtractMjpegFrame'' |
| ''std.video.mp4'' | MP4/ISOBMFF-Reader (VID-02): ''Mp4Meta'', ''Mp4MetaFile''; Box-Traversierung moov→mvhd→trak→tkhd→mdia→stsd |
import std.video.core;
import std.video.mp4;
import std.alloc;
import std.io;
fn main(): int64 {
var vid: int64 := alloc(VID_SIZE);
if (Mp4MetaFile("film.mp4"c as int64, 0, vid) == 0) { return 1; }
var w: int64 := peek64(vid + VID_OFF_WIDTH);
var h: int64 := peek64(vid + VID_OFF_HEIGHT);
var dur: int64 := peek64(vid + VID_OFF_DURATION_MS) / 1000;
PrintLn(IntToStr(w) + "x" + IntToStr(h) + " Dauer: " + IntToStr(dur) + "s");
free(vid, VID_SIZE);
return 0;
}
-----
===== OpenPGP =====
Vier Units für OpenPGP nach RFC 4880. Das Paket ist eine **Parser- und Codec-Bibliothek**: ASCII-Armor lesen und schreiben, binäre Paket-Ströme iterieren, Public-Key-Metadaten extrahieren. Kein Schlüssel-Generieren, kein Ver-/Entschlüsseln, kein Signieren.
→ Details: [[lyx_-_programmiersprache:units:pgp|std.pgp Übersicht]]
^ Unit ^ Beschreibung ^
| ''std.pgp.core'' | Konstanten: ''PGP_TAG_*'' (19 Paket-Tags), ''PGP_ALG_*'' (8 Algorithmen), ''PGP_HASH_*'', ''PGP_SYM_*'', ''PGP_SIG_*'' (Signaturtypen), ''PGP_ARMOR_*''; ''PgpPacketInfo''-Struct-Offsets (32 Bytes); ''PgpCrc24'' (RFC 4880 §6.1, Init 0xB704CE, Poly 0x1864CFB) |
| ''std.pgp.armor'' | ''PgpArmorEncode'' (Binär → Base64+Header+CRC), ''PgpArmorDecode'' (Base64-Decode + CRC-24-Verifikation, -1 bei Fehler), ''PgpArmorType'' (erkennt PUBLIC KEY / PRIVATE KEY / MESSAGE / SIGNATURE) |
| ''std.pgp.packet'' | ''PgpPacketFirst''/''PgpPacketNext'': Zero-Copy-Iterator über Old-Format- und New-Format-Pakete; ''PGP_PKT_OFF_BODY'' zeigt direkt in Quell-Buffer |
| ''std.pgp.key'' | ''PgpKeyVersion'' (3 oder 4), ''PgpKeyAlgo'' (''PGP_ALG_*''), ''PgpKeyTimestamp'' (Unix-Sekunden), ''PgpKeyFingerprint'' (v4: 20-Byte SHA-1), ''PgpKeyId'' (letzte 8 Bytes des Fingerprints); nur v4 für Fingerprint |
import std.pgp.core;
import std.pgp.armor;
import std.pgp.packet;
import std.pgp.key;
import std.alloc;
fn ReadPublicKey(armText: int64, armLen: int64): void {
// Armor dekodieren
var raw: int64 := alloc(armLen);
var rawLen: int64 := PgpArmorDecode(armText, armLen, raw, armLen);
if (rawLen < 0) { free(raw, armLen); return; }
// Pakete iterieren
var pkt: int64 := alloc(PGP_PKT_SIZE);
var fp: int64 := alloc(20);
if (PgpPacketFirst(raw, rawLen, pkt) != 0) {
var more: int64 := 1;
while (more != 0) {
var tag: int64 := peek64(pkt + PGP_PKT_OFF_TAG);
var body: int64 := peek64(pkt + PGP_PKT_OFF_BODY);
var blen: int64 := peek64(pkt + PGP_PKT_OFF_BLEN);
if (tag == PGP_TAG_PUBKEY) {
PgpKeyFingerprint(body, blen, fp);
// fp[0..19] = 20-Byte SHA-1 Fingerprint
}
more := PgpPacketNext(raw, rawLen, pkt);
}
}
free(pkt, PGP_PKT_SIZE);
free(fp, 20);
free(raw, armLen);
}
-----
===== HL7 v2 =====
Vier Units für HL7 Version 2 — den Datenaustauschstandard im Gesundheitswesen. Abgedeckt ist der gesamte Stack: MLLP-Framing, MSH-Parser, ACK-Engine, Patientenverwaltung (ADT), Auftragswesen (ORM/OML) und Befundübermittlung (ORU/OUL).
→ Details und Nachrichtenflüsse: [[lyx_-_programmiersprache:units:hl7|std.hl7 Übersicht]]
^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:hl7:core|std.hl7.core]] | MLLP-Framing (VT+FS+CR), MSH-Parser, ACK-Generator (AA/AE/AR), Dedup-State (FNV1a, 16 Partner × 64-Ring), Versions- und Testmodus-Prüfung |
| [[lyx_-_programmiersprache:units:hl7:adt|std.hl7.adt]] | Patient Administration (ADT^Axx): PID (3 ID-Slots, Name, Geburt, Geschlecht), PV1 (Klasse, Bett, Arzt, Zeiten), MRG (Merge), NK1 (Angehörige); ''Hl7AdtParse''/''Write''; Merge-Erkennung (A34–A45) |
| [[lyx_-_programmiersprache:units:hl7:orders|std.hl7.orders]] | Order Management (ORM^O01, OML^O21, RAS^O17): ORC (Kontroll-Code, Placer/Filler), OBR (Service-ID, Priorität, Zeiten), RXA (Medikamentengabe); STAT-Erkennung; ''Hl7OrrWrite'' (ORR^O02/ORL^O22) |
| [[lyx_-_programmiersprache:units:hl7:results|std.hl7.results]] | Result Reporting (ORU^R01, OUL^R22): OBX (Wertetyp, LOINC, Wert, UCUM-Einheit, Referenzbereich, Abnormal-Flag, Status); automatische Panikwert- (HH/LL/AA/CC) und Korrektur-Erkennung (C/W); NTE-Kommentare |
import std.hl7.core;
import std.hl7.adt;
import std.alloc;
fn handleAdt(msgBuf: int64, msgLen: int64, state: int64): void {
var msh: int64 := alloc(HL7_MSH_SIZE);
if (Hl7MshParse(msgBuf, msgLen, msh) != HL7_OK) {
free(msh, HL7_MSH_SIZE);
return;
}
var adt: int64 := alloc(HL7_ADT_SIZE);
Hl7AdtParse(msgBuf, msgLen, adt);
// Patientenname und Bett ausgeben
var fam: int64 := peek64(adt + HL7_ADT_PID + HL7_PID_FAMILY);
var bed: int64 := peek64(adt + HL7_ADT_PV1 + HL7_PV1_LBED);
// ACK senden
var ackBuf: int64 := alloc(512);
var ackLen: int64 := Hl7AckWrite(msh, "AA"c as int64, "OK"c as int64, ackBuf, 512);
var outBuf: int64 := alloc(600);
MllpFrameWrite(outBuf, 600, ackBuf, ackLen);
free(outBuf, 600);
free(ackBuf, 512);
free(adt, HL7_ADT_SIZE);
free(msh, HL7_MSH_SIZE);
}
-----
Letzte Aktualisierung: 2026-06-16