====== Lyx - Datentypen ======

Diese Seite gibt einen technischen Überblick über die aktuell unterstützten Datentypen in **Lyx** sowie deren Implementierungsstatus im Compiler.

===== Aktuell unterstützte Datentypen =====

==== 1. Ganzzahl-Typen (signiert) ====

^ Typ ^ Bits ^ Wertebereich ^ Status ^ Literale ^
| `int8`  | 8  | -128 bis 127 | ✅ Full | `42i8` |
| `int16` | 16 | -32,768 bis 32,767 | ✅ Full | `42i16` |
| `int32` | 32 | -2,147,483,648 bis 2,147,483,647 | ✅ Full | `42i32` |
| `int64` | 64 | -9,223,372,036,854,775,808 bis … | ✅ Full | `42` |
| `int`   | 64 | Alias für `int64` | ✅ Full | `42` |

==== 2. Ganzzahl-Typen (unsigniert) ====

^ Typ ^ Bits ^ Wertebereich ^ Status ^ Literale ^
| `uint8`  | 8  | 0 bis 255 | ✅ Full | `42u8` |
| `uint16` | 16 | 0 bis 65,535 | ✅ Full | `42u16` |
| `uint32` | 32 | 0 bis 4,294,967,295 | ✅ Full | `42u32` |
| `uint64` | 64 | 0 bis 18,446,744,073,709,551,615 | ✅ Full | `42u64` |

==== 3. Plattform-abhängige Typen ====

^ Typ ^ Beschreibung ^ Status ^ Anmerkung ^
| `isize` | Pointer-Größe (signiert) | ⚠️ Partial | Definiert, kaum getestet |
| `usize` | Pointer-Größe (unsigniert) | ⚠️ Partial | Definiert, kaum getestet |

==== 4. Fließkomma-Typen ====

^ Typ ^ Bits ^ IEEE 754 ^ Status ^ Literale ^
| `f32` | 32 | single | ✅ REPARIERT | `3.14` |
| `f64` | 64 | double | ✅ REPARIERT | `3.14` |

**Status:** Lexer, Parser, AST und Sema implementiert. IR-Lowering derzeit Platzhalter (Dummy-Wert).

==== 5. Zeichen- und String-Typen ====

^ Typ ^ Beschreibung ^ Status ^ Literale ^
| `char`  | Ein ASCII-Zeichen | ✅ REPARIERT | `'a'` |
| `pchar` | Nullterminierter String | ✅ Full | `"hello"` |
| `string`| Alias für `pchar` | ✅ Full | `"hello"` |

==== 6. Sonstige Typen ====

^ Typ ^ Beschreibung ^ Status ^ Verwendung ^
| `bool` | Wahrheitswert | ✅ Full | `true`, `false` |
| `void` | Kein Rückgabewert | ✅ Full | Funktionen |

==== 7. Interne Typen ====

^ Typ ^ Verwendung ^
| `atUnresolved` | Temporär während Typprüfung |

===== Status-Legende =====

  * ✅ **Full** – Parser, Sema, IR und Codegen vorhanden
  * ⚠️ **Partial** – Teilweise implementiert
  * ❌ **Missing** – Definiert, aber nicht umgesetzt
  * 🔄 **WIP** – Work in Progress

===== Implementierungsdetails =====

==== Storage-Klassen-Kompatibilität ====

^ Storage ^ Beschreibung ^ Status ^
| `var` | Veränderbar | ✅ Integer + bool |
| `let` | Immutable | ✅ Integer + bool |
| `co`  | Runtime-readonly | ✅ Funktionsfähig |
| `con` | Compile-time constant | ✅ Repariert |

**Getestet:**

  * Integer-Typen (8–64 Bit, signed/unsigned)
  * bool
  * Funktionsrückgaben
  * automatische Integer-Konvertierung

==== Typkonvertierung ====

  * **Automatisch:** Integer ↔ Integer (verschiedene Breiten)
  * **Explizit:** Cast-Operatoren geplant
  * **Constant Folding:** Literale werden auf Zieltyp angepasst

==== Code-Generation-Status ====

=== Vollständig ===

  * Integer-Typen
  * `bool`, `char`, `pchar`
  * Load/Store mit korrekter Breite

=== Teilweise ===

  * `f32`, `f64` – Frontend OK, Backend fehlt
  * `isize`, `usize` – Tests fehlen

=== Fehlend ===

  * Union-Typen
  * Pointer-Arithmetik
  * Dynamische Arrays

===== Status-Update: HEAD-Version (0d50afd) =====

==== Erfolgreich behoben ====

  * Syntaxfehler (`end;` Statements) repariert
  * `con` Parser-Bug behoben
  * Bracket-Tokens `[ ]` ergänzt
  * HEAD kompiliert wieder sauber

==== Teststatus ====

  * Integer-Typen: int8..uint64 ✅
  * Boolean-Literale ✅
  * Char-Literale + Escape-Sequenzen ✅
  * Float-Literale (`3.14`) ✅
  * Array-Literal-Syntax `[1,2,3]` (Frontend) ✅
  * Storage-Klassen var/let/co/con ✅
  * Funktionsrückgaben aller primitiven Typen ✅

===== Bekannte Einschränkungen =====

==== Char-Literale ====

Vollständig implementiert:

  * Lexer `tkCharLit`
  * AST-Knoten
  * Escape-Sequenzen (`\n`, `\t`, `\\`, `\'`, `\0`)

==== Fließkomma-Typen ====

Frontend vollständig, Backend noch Platzhalter.

==== Array-Literale ====

Parser und Sema vorhanden, echter Codegen folgt.

==== Platform-Types ====

`isize`/`usize` implementiert, aber kaum getestet.

===== Test-Abdeckung =====

==== Vollständig getestet ====

  * Integer-Typen
  * bool
  * String-Literale (`pchar`)
  * Funktionsrückgaben

==== Nicht getestet ====

  * Overflow/Underflow Edge-Cases
  * Sehr große Literale
  * Cross-Architektur Verhalten von `isize`/`usize`

===== Roadmap =====

==== Backend-Implementierungen ====

  * Float-IR Backend
  * Array-IR Backend
  * Erweiterte Array-Typen

==== Kurzfristig ====

  * Float-Codegen vervollständigen
  * Tests für isize/usize
  * Integer-Overflow Tests

==== Mittelfristig ====

  * Explizite Casts (`x as int32`)
  * Structs/Records
  * Statische Arrays

==== Langfristig ====

  * Generics/Templates
  * Union-Typen
  * Smart-Pointer

===== Beispiele =====

<code lyx>
var a: int8 := 127;
let b: uint16 := 65535;
con d: int64 := 9223372036854775807;

var pi: f32 := 3.14159;
let e: f64 := 2.718281828;

var ch: char := 'X';
let msg: pchar := "Hello";

var flag: bool := true;

fn get_byte(): uint8 { return 255; }
fn get_flag(): bool { return true; }
fn do_nothing(): void { print_str("done"); } </code>