std.edi.core

EDIFACT-Interchange-Engine — das Fundament aller std.edi.*-Units. Implementiert die vollständige Umschlag-Hierarchie (UNA / UNB / UNZ / UNG / UNE / UNH / UNT), den Segment-Tokenizer mit Escape-Behandlung, laufende Sequenznummern und Duplikatserkennung pro Partner.

Alle anderen EDI-Units importieren std.edi.core und setzen die hier definierten Structs und Konstanten voraus.

import std.edi.core;

// 1. Kontext allozieren und initialisieren
var ctx: int64 := alloc(EDI_CTX_SIZE);
EdiCtxInit(ctx);

// Absender / Empfänger setzen (Zeiger in eigene Puffer, kein Copy)
poke64(ctx + EDI_CTX_SENDER, "MYCOMPANY" as int64);
poke64(ctx + EDI_CTX_SNDLEN, 9);
poke64(ctx + EDI_CTX_RCVR,   "PARTNER01" as int64);
poke64(ctx + EDI_CTX_RCVLEN, 9);

// 2. State für Sequenznummern / Duplikatserkennung
var state: int64 := alloc(EDI_STATE_SIZE);
EdiStateInit(state);

// 3. UNB-Header schreiben
var out: int64 := alloc(65536);
var pos: int64 := EdiUnbWrite(ctx, out, 65536);

free(out, 65536);
free(state, EDI_STATE_SIZE);
free(ctx, EDI_CTX_SIZE);

• std.alloc

Wenn kein UNA-Segment vorhanden ist, gelten folgende Standardwerte (UNOA-Zeichensatz):

Zeichensatz-Codes:

Fehlercodes:

Alle Structs werden vom Caller alloziert. Größen sind über Konstanten verfügbar.

Hält die Trennzeichen aus dem UNA-Segment oder die Standardwerte.

Hält die aktuelle Position im Lesepuffer. Wird von EdiSegCtxInit initialisiert und von EdiSegmentNext fortgeschrieben.

Speichert pro Partner (max. 16) die laufende Sequenznummer und einen Ring-Buffer von 128 ICR-Hashes zur Duplikatserkennung.

import std.edi.core;

fn parseEdi(buf: int64, bufLen: int64): void {
    // 1. UNA-Trennzeichen ermitteln (oder Standardwerte)
    var una: int64 := alloc(EDI_UNA_SIZE);
    EdiUnaRead(buf, bufLen, una);

    // UNB steht nach UNA (9 Bytes) oder am Anfang
    var startPos: int64 := 0;
    if (peek8(buf) == 85 && peek8(buf+1) == 78 && peek8(buf+2) == 65) {
        startPos := 9;
    }

    // 2. Segment-Iterator initialisieren
    var sctx: int64 := alloc(EDI_SEGCTX_SIZE);
    EdiSegCtxInit(sctx, una, startPos);

    var seg:   int64 := alloc(EDI_SEG_SIZE);
    var elems: int64 := alloc(16 * EDI_ELEM_SIZE);

    var done: int64 := 0;
    while (done == 0) {
        var r: int64 := EdiSegmentNext(buf, bufLen, sctx, seg);
        if (r == 0) {
            done := 1;
        } else {
            var n: int64 := EdiElementSplit(seg, elems, 16);
            // Segment-Tag aus erstem Element auslesen
            var tag: int64 := peek64(seg + EDI_SEG_PTR);
            PrintLn("Segment: " + (tag as pchar));
        }
    }

    free(elems, 16 * EDI_ELEM_SIZE);
    free(seg,   EDI_SEG_SIZE);
    free(sctx,  EDI_SEGCTX_SIZE);
    free(una,   EDI_UNA_SIZE);
}

• Zero-Copy-Parsing: EdiSegmentNext, EdiElementSplit und EdiComponentSplit setzen Zeiger in den Originalpuffer — keine Kopien. Der Puffer muss während der gesamten Verarbeitung gültig bleiben.
• Caller alloziert: Alle Structs (UNA, CTX, SEGCTX, SEG, Elem-Arrays) werden vom Caller alloziert und freigegeben. Die Größenkonstanten (EDI_*_SIZE) geben die benötigte Byte-Anzahl an.
• Escape-Behandlung: EdiSegmentNext behandelt das Release-Zeichen (Standard: ?) korrekt — es schützt das darauffolgende Trennzeichen vor Interpretation. Explizite Daten müssen danach durch EdiUnescape bereinigt werden.
• Duplikatserkennung: EdiDuplicateCheck nutzt einen Ring-Buffer mit 128 Hash-Einträgen pro Partner. Bei mehr als 128 ICRs pro Partner kann ein alter ICR wieder als „neu“ erscheinen.

Letzte Aktualisierung: 2026-06-16