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