std.edi.delfor

Lieferabrufe per EDIFACT: rollierender Lieferzeitplan (DELFOR) und Just-in-Time-Abruf (DELJIT). DELFOR unterstützt bis zu 52 Anforderungen pro Position (52 Kalenderwochen), unterscheidet zwischen festen (Typ 1) und Planungsbedarfen (Typ 3) und enthält eine Kumulationsprüfung.

DELFOR (BGM 241) — Delivery Forecast: rollierende Lieferplanung mit Fest- und Planbedarfen
DELJIT (BGM 251) — Delivery Just In Time: Minutengenaue Abrufzeitpunkte (DTM Qualifier 201, Format CCYYMMDDHHMM)

import std.edi.delfor;
import std.alloc;
import std.string;

fn Feld(p: int64, l: int64): pchar {
    var b: int64 := alloc(l + 1);
    var i: int64 := 0;
    while (i < l) { poke8(b + i, peek8(p + i)); i := i + 1; }
    poke8(b + l, 0);
    return b as pchar;
}

fn main(): int64 {
    // DELFOR: eine Materialnummer, drei Abrufe (1x fest, 2x Vorschau)
    var lines: int64 := alloc(EDI_DELFOR_LINE_SIZE);
    var i: int64 := 0;
    while (i < EDI_DELFOR_LINE_SIZE) { poke8(lines + i, 0); i := i + 1; }
    poke64(lines + EDI_DELFOR_LINE_GTIN,     "04012345678901"c as int64);
    poke64(lines + EDI_DELFOR_LINE_GTINLEN,  14);
    poke64(lines + EDI_DELFOR_LINE_CUMULQTY, 12000);   // Fortschrittszahl
    poke64(lines + EDI_DELFOR_LINE_REQCOUNT, 3);

    var req: int64 := lines + EDI_DELFOR_LINE_REQS;
    poke64(req + EDI_DELFOR_REQ_DATE, "20260817"c as int64);
    poke64(req + EDI_DELFOR_REQ_QTY,  600);
    poke64(req + EDI_DELFOR_REQ_TYPE, 1);              // 1 = fester Abruf
    var r1: int64 := req + EDI_DELFOR_REQ_SIZE;
    poke64(r1 + EDI_DELFOR_REQ_DATE, "20260824"c as int64);
    poke64(r1 + EDI_DELFOR_REQ_QTY,  600);
    poke64(r1 + EDI_DELFOR_REQ_TYPE, 3);               // 3 = Planzahl
    var r2: int64 := req + 2 * EDI_DELFOR_REQ_SIZE;
    poke64(r2 + EDI_DELFOR_REQ_DATE, "20260831"c as int64);
    poke64(r2 + EDI_DELFOR_REQ_QTY,  450);
    poke64(r2 + EDI_DELFOR_REQ_TYPE, 3);

    var out: int64 := alloc(8192);
    var n: int64 := EdiDelforWrite("ABR-2026-33"c, "20260813"c, lines, 1, out, 8192);
    PrintLn(Feld(out, n));

    var l2: int64 := alloc(2 * EDI_DELFOR_LINE_SIZE);
    var cnt: int64 := EdiDelforRead(out, n, l2, 2);
    PrintLn(StrConcat(StrConcat("Zeilen: ", IntToStr(cnt)),
            StrConcat("  Abrufe: ", IntToStr(peek64(l2 + EDI_DELFOR_LINE_REQCOUNT)))));

    // Fortschrittszahl darf nie sinken
    PrintLn(StrConcat("Kumulativ 12600 nach 12000 ok: ", IntToStr(EdiDelforCheckCumu(12600, 12000))));
    PrintLn(StrConcat("Kumulativ 11000 nach 12000 ok: ", IntToStr(EdiDelforCheckCumu(11000, 12000))));

    // DELJIT: minutengenauer Feinabruf an ein Werkstor
    var jl: int64 := alloc(EDI_DELJIT_LINE_SIZE);
    i := 0;
    while (i < EDI_DELJIT_LINE_SIZE) { poke8(jl + i, 0); i := i + 1; }
    poke64(jl + EDI_DELJIT_LINE_GTIN,     "04012345678901"c as int64);
    poke64(jl + EDI_DELJIT_LINE_GTINLEN,  14);
    poke64(jl + EDI_DELJIT_LINE_QTY,      120);
    poke64(jl + EDI_DELJIT_LINE_DATETIME, "202608170615"c as int64);
    poke64(jl + EDI_DELJIT_LINE_DTLEN,    12);
    poke64(jl + EDI_DELJIT_LINE_LOC,      "TOR-7"c as int64);
    poke64(jl + EDI_DELJIT_LINE_LOCLEN,   5);
    n := EdiDeljitWrite("JIT-2026-4711"c, "20260816"c, jl, 1, out, 8192);
    PrintLn(Feld(out, n));
    return 0;
}

BGM+241+ABR-2026-33+9'DTM+137:20260813:102'LIN+1++04012345678901:SRV'SCC+1+12000'QTY+1:600'DTM+64:20260817:102'QTY+3:600'DTM+64:20260824:102'QTY+3:450'DTM+64:20260831:102'CNT+2:1'
Zeilen: 1  Abrufe: 3
Kumulativ 12600 nach 12000 ok: 0
Kumulativ 11000 nach 12000 ok: 1
BGM+251+JIT-2026-4711+9'DTM+137:20260816:102'LIN+1++04012345678901:SRV'DTM+201:202608170615:201'QTY+1:120'LOC+11:TOR-7'CNT+2:1'

Die Fortschrittszahl steht im SCC-Segment, jeder Abruf als Paar aus QTY (Qualifier 1 = fest, 3 = Vorschau) und DTM+64. Der JIT-Abruf trägt stattdessen einen minutengenauen Termin (DTM+201, Format CCYYMMDDHHMM) und den Anlieferort im LOC+11.

Imports

std.edi.core
std.alloc

Konstanten

Konstante	Wert	Bedeutung
`EDI_DELFOR_REQ_TYPE` = 1	1	Festbedarf (QTY-Qualifier: 1)
`EDI_DELFOR_REQ_TYPE` = 3	3	Planungsbedarf (QTY-Qualifier: 3)
`EDI_DELFOR_MAX_REQ`	52	Max. Anforderungen pro Position (52 Wochen)

Structs

EdiDelforReq (EDI_DELFOR_REQ_SIZE = 24 Bytes)

Eine einzelne Mengenanforderung innerhalb einer DELFOR-Position.

Offset-Konstante	Inhalt
`EDI_DELFOR_REQ_DATE`	Zeiger auf Datum „YYYYMMDD“
`EDI_DELFOR_REQ_QTY`	Menge (QTY+type:qty)
`EDI_DELFOR_REQ_TYPE`	1 = Festbedarf, 3 = Planungsbedarf

EdiDelforLine (EDI_DELFOR_LINE_SIZE = 1 280 Bytes)

Eine Position im Lieferabruf. Die Struktur ist groß wegen des internen Anforderungs-Arrays: 32 Bytes (Kopf) + 52 × 24 Bytes (Anforderungen) = 1 280 Bytes.

Offset-Konstante	Inhalt
`EDI_DELFOR_LINE_GTIN / EDI_DELFOR_LINE_GTINLEN`	GTIN-Zeiger und -Länge
`EDI_DELFOR_LINE_CUMULQTY`	Kumulative Gesamtmenge (SCC-Segment)
`EDI_DELFOR_LINE_REQCOUNT`	Anzahl der Anforderungen (0–52)
`EDI_DELFOR_LINE_REQS`	Start des Anforderungs-Arrays (Offset 32)

Anforderungs-Array-Zugriff:

// i-te Anforderung einer Zeile
var req: int64 := line + EDI_DELFOR_LINE_REQS + i * EDI_DELFOR_REQ_SIZE;

EdiDeljitLine (EDI_DELJIT_LINE_SIZE = 56 Bytes)

Eine Position im JIT-Abruf.

Offset-Konstante	Inhalt
`EDI_DELJIT_LINE_GTIN / EDI_DELJIT_LINE_GTINLEN`	GTIN-Zeiger und -Länge
`EDI_DELJIT_LINE_QTY`	Abrufmenge
`EDI_DELJIT_LINE_DATETIME / EDI_DELJIT_LINE_DTLEN`	Zeiger auf 12-Zeichen-Datetime „CCYYMMDDHHMM“
`EDI_DELJIT_LINE_LOC / EDI_DELJIT_LINE_LOCLEN`	Lieferort (optional)

Funktionen

DELFOR

Signatur	Beschreibung
`EdiDelforWrite(refNum: int64, date: int64, lines: int64, lineCount: int64, out: int64, outMax: int64): int64`	Schreibt DELFOR. Fest- und Planbedarfe werden über QTY-Qualifier 1 bzw. 3 kodiert.
`EdiDelforRead(buf: int64, bufLen: int64, lines: int64, maxLines: int64): int64`	Parst DELFOR; befüllt `lines`-Array. Gibt Zeilenanzahl zurück.
`EdiDelforCheckCumu(newCumu: int64, oldCumu: int64): int64`	Kumulationsvalidierung: neue Menge muss ≥ alte Menge sein. Gibt 0=ok, 1=Warnung (unerwartete Rückwärts-Kumulation).

DELJIT

Signatur	Beschreibung
`EdiDeljitWrite(refNum: int64, date: int64, lines: int64, lineCount: int64, out: int64, outMax: int64): int64`	Schreibt DELJIT mit minutengenauem Zeitstempel (DTM Qualifier 201)
`EdiDeljitRead(buf: int64, bufLen: int64, lines: int64, maxLines: int64): int64`	Parst DELJIT; gibt Zeilenanzahl zurück

Hinweise

Speicherbedarf DELFOR: EDI_DELFOR_LINE_SIZE = 1 280 Bytes pro Position (52 Wochen × 24 Bytes). Bei 100 Positionen sind das 128 KB — vor der Allokation prüfen.
Datetime-Format DELJIT: Das 12-Zeichen-Format CCYYMMDDHHMM hat kein Trennzeichen: 202612011430 = 01.12.2026 um 14:30 Uhr.
Kumulationslogik: Die kumulative Menge (SCC-Segment) wächst über den Lieferabruf-Zeitraum monoton. EdiDelforCheckCumu(neu, alt) liefert 0 wenn die Reihenfolge stimmt und 1 bei gesunkener Fortschrittszahl — ein Signal für einen Abruf-Reset (neuer Bezugszeitraum) oder einen Datenfehler. Die alte Zahl muss der Aufrufer selbst vorhalten; die Unit merkt sich nichts.
Abrufarten: EDI_DELFOR_REQ_TYPE 1 = fester Abruf (verbindlich), 3 = Planzahl (Vorschau). Beide landen im QTY-Qualifier.
Maximal 52 Abrufe je Position (EDI_DELFOR_MAX_REQ); EDI_DELFOR_LINE_REQCOUNT sagt, wie viele davon belegt sind.

Quelldatei

Unit	Datei
`std.edi.delfor`	`std/edi/delfor.lyx`

Letzte Aktualisierung: 2026-08-13 — durchgehendes, lauffähiges Beispiel für DELFOR (mit Abrufkette und Kumulationsprüfung) und DELJIT, ausgeführt mit lyxc 1.0.17K; Rückgabewert von EdiDelforCheckCumu (0 = ok) klargestellt

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).