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