std.zip — ZIP-Archive lesen und schreiben

std.zip liest und schreibt ZIP-Archive nach PKWARE APPNOTE. Die Unit implementiert die Kompressionsmethoden stored (method 0) und deflated (method 8, via std.zlib) und wählt beim Schreiben automatisch die günstigere Variante. Keine externen Abhängigkeiten außer std.zlib für die Kompression.

→ Standard Library · std.tar · std.rar

Einschränkungen: Max. 4096 Einträge pro Archiv. Keine ZIP64-Unterstützung — Einzeldateien sind auf ~2 GB begrenzt. Kein Passwortschutz.

Konstanten

Konstante	Wert	Bedeutung
`ZIP_MAX_ENTRIES`	4096	Maximale Einträge pro Archiv
`ZIP_METHOD_STORE`	0	Kompressionsmethode: unkomprimiert
`ZIP_METHOD_DEFLATE`	8	Kompressionsmethode: DEFLATE
`ZIP_STORE_THRESHOLD`	64	Dateien ≤ 64 Bytes werden immer stored
`ZIP_ERR_OK`	0	Kein Fehler
`ZIP_ERR_NOTZIP`	1	Keine gültige ZIP-Datei
`ZIP_ERR_IO`	2	I/O-Fehler beim Lesen oder Schreiben
`ZIP_ERR_CORRUPT`	3	Archiv beschädigt
`ZIP_ERR_FULL`	4	ZIP_MAX_ENTRIES erreicht

Lesen (ZipReader)

Funktion	Rückgabe	Beschreibung
`ZipOpen(path)`	`int64` Handle oder 0	Öffnet ZIP-Archiv aus Datei
`ZipClose(handle)`	`void`	Gibt Handle und alle Ressourcen frei
`ZipCount(handle)`	`int64`	Anzahl der Einträge
`ZipName(handle, idx)`	`int64` pchar	Name des idx-ten Eintrags (interner Puffer — nicht free'n)
`ZipUncompSize(handle, idx)`	`int64`	Unkomprimierte Größe in Bytes
`ZipRead(handle, idx, outBuf, maxLen)`	`int64` Bytes oder -1	Dekomprimiert Eintrag in outBuf
`ZipFind(handle, name)`	`int64` Index oder -1	Sucht Eintrag nach Namen

ZipRead dekomprimiert automatisch (stored oder deflated). outBuf muss mindestens ZipUncompSize Bytes groß sein.

import std.zip;
import std.alloc;
import std.io;

fn ZipInhaltLesen(pfad: pchar): void {
    var z: int64 := ZipOpen(pfad as int64);
    if z == 0 then { PrintLn("Kein gültiges ZIP"c); return; }

    var n: int64 := ZipCount(z);
    Print("Einträge: "c); PrintLn(IntToStr(n)c);

    var i: int64 := 0;
    while i < n do {
        Print(ZipName(z, i) as pchar);
        Print("  "c);
        PrintLn(IntToStr(ZipUncompSize(z, i))c);
        i := i + 1;
    }

    // Einzelne Datei lesen
    var idx: int64 := ZipFind(z, "config.json"c as int64);
    if idx >= 0 then {
        var sz: int64  := ZipUncompSize(z, idx);
        var buf: int64 := alloc(sz + 1);
        ZipRead(z, idx, buf, sz);
        poke8(buf + sz, 0);
        PrintLn(buf as pchar);
        free(buf, sz + 1);
    }

    ZipClose(z);
}

Schreiben (ZipWriter)

Funktion	Rückgabe	Beschreibung
`ZipWriterNew()`	`int64` Writer-Handle	Erstellt neuen leeren Writer
`ZipWriterAdd(writer, name, data, dataLen)`	`int64` Fehlercode	Fügt Eintrag hinzu (kopiert Name + Daten)
`ZipWriterSave(writer, path)`	`int64` Fehlercode	Schreibt Archiv in Datei
`ZipWriterFree(writer)`	`void`	Gibt Writer und alle Einträge frei

Methode wird automatisch gewählt: stored für ≤ 64 Bytes und wenn deflate keine Verbesserung bringt, sonst deflated.

import std.zip;
import std.alloc;

fn ZipErstellen(): void {
    var w: int64 := ZipWriterNew();

    var inhalt: pchar := "Hallo aus Lyx!"c;
    ZipWriterAdd(w, "hallo.txt"c as int64,
                 inhalt as int64, 14);

    var json: pchar := "{\"version\": 1}"c;
    ZipWriterAdd(w, "meta/config.json"c as int64,
                 json as int64, 14);

    var rc: int64 := ZipWriterSave(w, "ausgabe.zip"c as int64);
    if rc != ZIP_ERR_OK then {
        PrintLn("Fehler beim Speichern"c);
    }

    ZipWriterFree(w);
}

Speicherverwaltung

Handle	Freigabe
`ZipOpen` → Reader-Handle	`ZipClose(handle)`
`ZipWriterNew` → Writer-Handle	`ZipWriterFree(writer)`
`ZipName` → interner Puffer	nicht free'n — gehört dem Handle
`outBuf` in `ZipRead`	Aufrufer allokiert, Aufrufer gibt frei

Letzte Aktualisierung: 2026-06-13