====== Lyx – Programmiersprache – Überblick ======

Lyx ist eine kompakte, statisch typisierte, prozedurale Sprache mit einem nativen Compiler (geschrieben in FreePascal), der direkt ausführbare Binaries für mehrere Plattformen erzeugt – ohne externe Abhängigkeiten wie libc oder einen externen Linker (pure Syscalls oder WinAPI).

Der Fokus hat sich von einer reinen Linux x86_64-Sprache zu einem multitarget-fähigen System entwickelt, das echtes Cross-Compiling unterstützt.

Repository: [[https://github.com/SEOLizer/LyX-Compiler]]

===== TL;DR (Stand v0.5.7) =====

Output: Native Binaries für Linux (ELF64), Windows (PE64), macOS (Mach-O) und ESP32 (Xtensa).

Architekturen: x86_64, ARM64 (AArch64), Xtensa.

Runtime: Minimal – Builtins + direkte Syscalls, kein libc-Zwang.

Status: Hochentwickelt mit Generics, Pattern Matching, Exceptions und einer umfangreichen Standardbibliothek.

Besonderheit: Energy-Aware-Compiling zur Optimierung des Stromverbrauchs auf Instruction-Ebene.

===== Architektur & Ziele =====

Architektur-Stabilität: Strikte Trennung zwischen Frontend (targetneutral), Middle-End (IR-Optimierungen) und plattformspezifischen Backends.

IR-Level Optimizer (v0.5.0): Constant Folding, CSE, DCE, Copy Propagation und Strength Reduction.

Bootstrap-Fähigkeit: Ein Lyx-in-Lyx-Compiler befindet sich im Aufbau (Work-in-Progress).

Vorhersehbarkeit: Explizites Speichermodell und deterministisches Laufzeitverhalten.

===== Sprache (Kern & Features) =====

==== Moderne Syntax & Typen ====
Lyx kombiniert Pascal-Klarheit mit modernen Features wie dem Pipe-Operator (|>).

Erweiterte Typen:
^ Typ ^ Beschreibung ^
| int64 | Standard 64-bit Integer |
| f32 / f64 | Floating-Point (IEEE 754) |
| array | Dynamische Arrays (Heap, Fat-Pointer mit push/pop/len/free) |
| parallel Array | SIMD-optimierte Arrays für parallele Operationen |
| Map<K,V> | Assoziative Arrays (HashMaps) |
| QBool | Probabilistischer Boole'scher Typ (Quanten-inspiriert) |
| pchar? | Nullable Pointer mit Null-Coalescing Operator (??) |

==== Fortgeschrittene Features (v0.5.6+) ====

Generics: Monomorphisierung von Funktionen, z.B. fn max[T](a: T, b: T): T.

Pattern Matching: Mächtiges match/case System mit OR-Patterns.

Exceptions: try/catch/throw für robustes Error-Handling.

Multi-Return: Funktionen können Tupel zurückgeben: var a, b := f().

===== Standardbibliothek (std) =====

Lyx kommt mit einer "Batteries-included" Standardbibliothek:

std.net: Über 14 Protokolle (DNS, HTTP/S, SMTP, IMAP, MQTT, SNMP, SSH, BGP, SIP).

std.math: Umfassende mathematische Funktionen inkl. Fixed-Point und Geodaten-Berechnungen.

std.string: StringBuilder, Splitting und Formatierung.

std.fs & std.io: Dateisystem-Operationen und I/O-Abstraktionen.

===== Energy-Aware-Compiling =====

Einzigartig in Lyx ist die Möglichkeit, den Energieverbrauch des Zielprogramms zu steuern:

Global: Über den CLI-Flag --target-energy=<1-5> (1 = Minimaler Verbrauch/Batterie, 5 = Maximale Performance).

Lokal: Per Pragma @energy(level) für einzelne Funktionen.
Der Compiler liefert nach der Übersetzung detaillierte Energy Statistics über ALU/FPU-Operationen und Speicherzugriffe.

===== Backend & Cross-Compilation =====

Lyx unterstützt Cross-Compilation "out of the box":
<code>
./lyxc main.lyx -o main.exe --target=win64        # Windows x64
./lyxc main.lyx -o main --target=macos-arm64     # Apple Silicon
./lyxc main.lyx -o firmware.elf --target=esp32   # ESP32 (Xtensa)
</code>

^ Plattform ^ Architektur ^ ABI / Interface ^
| Linux | x86_64 / ARM64 | SysV / Syscalls |
| Windows | x86_64 | Win64 ABI / kernel32.dll |
| macOS | x86_64 / ARM64 | Mach-O / BSD Syscalls |
| ESP32 | Xtensa | ELF32 / ESP-Syscalls |

===== Projektstruktur =====

<code>
lyx-lang/
├── compiler/      # FPC-basierter Compiler (lyxc)
│   ├── frontend/  # Lexer, Parser, Sema, Linter (13 Regeln)
│   ├── ir/        # Intermediate Representation & Optimizer
│   └── backend/   # Emitter für ELF, PE, Mach-O, Xtensa
├── std/           # Standardbibliothek (in Lyx geschrieben)
├── bootstrap/     # Lyx-in-Lyx Projekt (Self-hosting)
└── tests/         # Umfangreiche Regression- & Feature-Tests
</code>

===== FAQ (Update) =====

Warum kein GC? Lyx nutzt explizites Ownership und free/dispose, um minimale Binaries und volle Kontrolle zu gewährleisten.

Was ist QBool? Ein spezieller Typ für probabilistische Logik (0.0 bis 1.0 Wahrscheinlichkeit), nützlich für Simulationen oder Quanten-Logik-Tests.

Wie stabil ist ARM64? Sehr stabil. Lyx unterstützt auf ARM64 volle dynamische Verlinkung (PLT/GOT) und alle Standard-Features.

[[lyx_-_programmiersprache:erste-schritte|Erste Schritte]]
[[lyx_-_programmiersprache:oop|Lyx – Objektorientierte Programmierung (OOP)]]
[[lyx_-_programmiersprache:arrays-maps|Lyx – Arrays & Maps]]
[[lyx_-_programmiersprache:arrays-datensammlungen|Arrays & Datensammlungen]]
[[lyx_-_programmiersprache:do-178c|DO-178C Compliance in Lyx]]
[[lyx_-_programmiersprache:schleifen|Schleifen in Lyx]]
[[lyx_-_programmiersprache:dedingungen|Bedingungen (if / else)]]
[[lyx_-_programmiersprache:Exception-Handling|Exception Handling]]
[[lyx_-_programmiersprache:Pointer-Inlining|Pointer & Inlining]]
[[lyx_-_programmiersprache:Attributes-Pragmas|Attributes & Pragmas (Metadaten)]]
[[lyx_-_programmiersprache:FFI|Interoperabilität (FFI)]]
[[lyx_-_programmiersprache:Generics-Traits|Generics & Traits]]
[[lyx_-_programmiersprache:Lyx-Compiler-selbst-kompilieren|Lyx Compiler selbst kompilieren]]
[[WCET Analyse (Worst Case Execution Time)]]
[[Bootstrapping & Bare Metal (Linker Scripts)]]