std.ini

INI-Konfigurationen lesen und schreiben: Sektionen ([server]), Schlüssel-Wert-Zeilen, Kommentare mit # und ;, typisierte Abfragen mit Vorgabewert, Iteration über Sektionen und Schlüssel, Laden und Speichern.

→ std.string · std.fs · Standard Library

Alle Beispiele dieser Seite sind mit lyxc 1.0.21A übersetzt und ausgeführt; die gezeigten Ausgaben sind echte Programmausgaben.

Einsatz: Anwendungs- und Dienstkonfiguration, Embedded-Systeme, Migrationsskripte — überall dort, wo eine lesbare Schlüssel-Wert-Datei ohne XML- oder JSON-Aufwand genügt.

Das „Dokument-Handle„ ist eine Kopie des INI-Textes im Speicher, kein Datenmodell. ParseString kopiert die Eingabe, alle weiteren Funktionen durchsuchen diesen Text bei jedem Aufruf von vorn.

Das hat zwei angenehme Folgen:

• Kommentare, Reihenfolge und Formatierung bleiben erhalten — ein Durchlauf Laden → Ändern → Speichern erhält die Datei so, wie sie war, samt Kopfzeilen und Einrückung.
• Der Zustand ist einfach: doc as pchar ist der vollständige Text und lässt sich direkt ausgeben.

Und eine unangenehme:

Werte werden getrimmt, und alles ab dem ersten # oder ; gilt als Kommentar — auch mitten in der Zeile.

import std.ini;
import std.alloc;
import std.string;

fn J(b: bool): pchar { if (b) { return "ja"; } return "nein"; }

fn main(): int64 {
    var text: pchar := "; Konfiguration\n[server]\nhost = example.org   ; Kommentar am Zeilenende\nport=8080\ndebug = true\nfaktor = 1.5\n\n[leer]\n"c;
    var doc: int64 := ParseString(text);

    // Typisierte Getter, jeweils mit Vorgabewert
    PrintLn(StrConcat("host:    ", GetString(doc, "server"c, "host"c, "?"c)));
    PrintLn(StrConcat("port:    ", IntToStr(GetInt(doc, "server"c, "port"c, 0))));
    PrintLn(StrConcat("debug:   ", J(GetBool(doc, "server"c, "debug"c, false))));
    PrintLn(StrConcat("fehlt:   ", GetString(doc, "server"c, "gibtsnicht"c, "Vorgabe"c)));
    PrintLn(StrConcat("Sektion fehlt: ", GetString(doc, "andere"c, "host"c, "Vorgabe"c)));

    // Bestand pruefen
    PrintLn(StrConcat("HasSection('server'):    ", J(HasSection(doc, "server"c))));
    PrintLn(StrConcat("HasKey('server','port'): ", J(HasKey(doc, "server"c, "port"c))));
    PrintLn(StrConcat("Sektionen insgesamt:     ", IntToStr(GetSectionCount(doc))));
    PrintLn(StrConcat("Schluessel in [server]:  ", IntToStr(GetKeyCount(doc, "server"c))));
    return 0;
}

host:    example.org
port:    8080
debug:   ja
fehlt:   Vorgabe
Sektion fehlt: Vorgabe
HasSection('server'):    ja
HasKey('server','port'): ja
Sektionen insgesamt:     2
Schluessel in [server]:  4

Ausgabeformat: Die Namen liegen dicht hintereinander, jeweils nullterminiert — kein festes Raster. Zum nächsten Namen kommt man über p + StrLen(p) + 1.

import std.ini;
import std.alloc;
import std.string;

// Sektions- und Schluesselnamen liegen dicht hintereinander, je nullterminiert
fn Naechster(p: int64): int64 { return p + StrLen(p as pchar) + 1; }

fn main(): int64 {
    // ACHTUNG: Der Dokumentpuffer ist nur so gross wie der Ausgangstext (#1426).
    // Deshalb hier von vornherein genug Text - oder gar nicht erst aendern.
    var doc: int64 := ParseString("[server]\nhost = example.org\nport = 8080\n\n[logging]\nlevel = info\n"c);

    var buf: int64 := alloc(4096);
    var i: int64 := 0;
    while (i < 4096) { poke8(buf + i, 0); i := i + 1; }

    var n: int64 := GetSections(doc, buf as pchar, 16);
    PrintLn(StrConcat("Sektionen: ", IntToStr(n)));
    var p: int64 := buf;
    i := 0;
    while (i < n) { PrintLn(StrConcat("  ", p as pchar)); p := Naechster(p); i := i + 1; }

    i := 0;
    while (i < 4096) { poke8(buf + i, 0); i := i + 1; }
    n := GetKeys(doc, "server"c, buf as pchar, 16);
    PrintLn(StrConcat("Schluessel in [server]: ", IntToStr(n)));
    p := buf; i := 0;
    while (i < n) { PrintLn(StrConcat("  ", p as pchar)); p := Naechster(p); i := i + 1; }

    // Zeilen von Hand bauen - fuer eigene Ausgabe ohne Set...
    var o: pchar := alloc(256) as pchar;
    BuildSectionHeader("db"c, o);       PrintLn(StrConcat("Kopfzeile:  ", o));
    BuildKeyValueLine("user"c, "lyx"c, o); PrintLn(StrConcat("Wertzeile:  ", o));

    // Namen pruefen, bevor sie geschrieben werden
    PrintLn(StrConcat("IsValidSectionName('a b'): ", IntToStr(IsValidSectionName("a b"c) as int64)));
    PrintLn(StrConcat("IsValidKeyName('po rt'):   ", IntToStr(IsValidKeyName("po rt"c) as int64)));
    return 0;
}

Sektionen: 2
  server
  logging
Schluessel in [server]: 2
  host
  port
Kopfzeile:  [db]
Wertzeile:  user=lyx
IsValidSectionName('a b'): 0
IsValidKeyName('po rt'):   0

Alle Set…-Funktionen geben nichts zurück — ob die Änderung gelungen ist, lässt sich nur über ein anschließendes HasKey oder GetString feststellen. Der Überlauf beim Wachsen ist behoben (#1426, nachgemessen mit lyxc 1.1.11B): ein Wert darf länger werden als der, den er ersetzt. ParseString weist außerdem ein Dokument ab, das INI_BUFFER_SIZE erreicht, und liefert dann 0.

Die Löschfunktionen verkürzen den Text und sind deshalb unbedenklich; ein Durchlauf Laden → Löschen → Speichern erhält Kommentare und Reihenfolge:

; Kopfkommentar
[s]
k = 1   # Zeilenkommentar

bleibt nach LoadFile + SaveFile unverändert erhalten.

Diese Bausteine erlauben es, eine INI-Datei zusammenzusetzen, ohne die Set…-Funktionen zu benutzen — der derzeit sicherste Weg, eine Datei neu zu schreiben.

• Nur lesen ist sicher. Jedes Set…, das den Text verlängert, überschreibt fremden Speicher (#1426).
• Jede Abfrage kostet Speicher (#1428) und durchsucht den gesamten Text linear — bei großen Dateien in Schleifen spürbar.
• ; und # im Wert beenden ihn — auch ohne Leerzeichen davor.
• Schlüssel- und Sektionsnamen werden nicht auf Gültigkeit geprüft, wenn man sie über SetString setzt; IsValidKeyName muss man selbst aufrufen.
• Groß- und Kleinschreibung zählt bei Sektions- und Schlüsselnamen.
• Kein Handle-Abbau. Weder ParseString noch LoadFile haben ein Gegenstück; der Dokumentpuffer bleibt bis zum Programmende belegt.
• Doppelte Schlüssel: Gefunden wird der erste Treffer in der Sektion; SetString ersetzt ebenfalls nur diesen.

Weiterführend: std.json · std.yaml · std.env · Standard Library

Quelle: std/ini.lyx (1069 Zeilen) · Autor: Andreas Röne · Copyright: 2024–2025 Andreas Röne

Letzte Aktualisierung: 2026-09-05 (#1427, nachgemessen mit lyxc 1.2.2B) — EscapeValue-Kasten auf den behobenen Stand gezogen.

Vorherige letzte Aktualisierung: 2026-08-13 — Seite gegen std/ini.lyx überarbeitet: zwei lauffähige Beispiele mit echter Ausgabe, das textbasierte Dokumentmodell und das Ausgabeformat von GetSections/GetKeys (dicht gepackt, nullterminiert) erstmals beschrieben, Fallstricke ergänzt. Belegt und als Issue erfasst: Dokumentpuffer wächst nicht mit (#1426), EscapeValue maskiert ;/# nicht (#1427), GetString leckt je Aufruf (#1428), die Grenzkonstanten sind wirkungslos (#1429). Geprüft mit lyxc 1.0.21A.

Letzte Aktualisierung: 2026-08-27 — Fallstricke gegen lyxc 1.1.11B nachgemessen: #1426 behoben (längere Werte, INI_BUFFER_SIZE wird geprüft), #1428 hat mit FreeString eine Freigabefunktion bekommen; #1427 (Semikolon im Wert) und #1429 (wirkungslose Grenzkonstanten) bestehen fort. Neu gefunden und gemeldet: WriteString schreibt einen festen Beispieltext (#1827).

Codebeispiele geprüft: gegen lyxc 1.2.5C übersetzt (Prüflauf 2026-09-08 über die gesamte Doku: 574 Vollprogramme, 0 echte Fehler; zusätzlich 5159 Aufrufe gegen die pub fn-Signaturen in aurum/std gehalten, 0 Abweichungen).