Technischer Artikel

Delphi vs. FPC: 4 PDF-Code-Fallen in PDFium-Builds

Derselbe Object-Pascal-Quellcode kann sich unter Delphi und FPC/Lazarus auf vier verschiedene Arten verhalten, die immer wieder zu Fehlern im Code der PDFium Component führen: FPC gibt temporäre Records aus Funktionsergebnissen frei, bevor eine in-Mengenprüfung sie vollständig gelesen hat. dcc32 liefert standardmäßig deaktivierte Bereichsprüfungen aus, sodass ungültige Array-Indizes stillschweigend Müll-Daten auslesen. Nur Delphi 13 akzeptiert die Zuweisung eines anonymen array of Byte an TBytes ohne Cast. Und Delphis AnsiString-Verkettung kann Bytes ab $80 über einen versteckten Codepage-Round-Trip beschädigen. Jedes davon erzeugt eine Suite, die auf dem einen Compiler grün ist und auf dem anderen rot — oder schlimmer, stillschweigend falsch

Wenn Sie zum ersten Mal ein Projekt für zwei Compiler einrichten, beschreibt der Leitfaden für Lazarus- und FPC-Viewer den einfachen Weg: Pakete, Suchpfade und das Anzeigen eines Rendering-Fensters. Dieser Artikel ist das Gegenteil eines Tutorials. Er behandelt, was schiefzugehen pflegt, nachdem der einfache Weg funktioniert — wenn eine Änderung, die auf dem einen Compiler durchläuft, auf dem anderen hochgeht. Jede Falle unten kommt mit einer minimalen Reproduktion, der Ursache und der Regel, auf die wir uns standardisiert haben

Warum wird eine Menge unter FPC als leer ausgelesen, in Delphi jedoch nicht?

Die Kurzfassung lautet: FPC kann die temporäre Variable, die das Record-Ergebnis einer Funktion hält, finalisieren, bevor ein Ausdruck, der ein Feld dieses Ergebnisses liest, abgeschlossen ist. Somit kann X in Func().Issues die Mitgliedschaft gegen eine bereits freigegebene Menge prüfen, während der entsprechende Delphi-Ausdruck funktioniert. Test-Assertions sind ein typischer Ort dafür: Ein PDF/E-Validator gibt einen Record zurück, dessen Feld Issues eine Menge von Verstoß-Flags ist, und es liegt nahe, den Aufruf in die Assertion zu inlinen

Diagramm: Delphi hält einen PDFium-Funktionsergebnis-Record temporär am Leben, bis die Anweisung endet, während FPC ihn freigibt, bevor der in-Operator das Issues-Set liest; die Assertion besteht nur unter Delphi
Delphi hält das Funktionsergebnis-Record-Temporär am Leben, bis die Anweisung endet, während FPC es freigeben kann, bevor der in-Operator die Issues-Menge liest
// Unzuverlässig unter FPC: Der temporäre Record aus dem Funktionsergebnis
// kann freigegeben werden, bevor die Mengenprüfung 'in' das Feld Issues liest.
AssertTrue(pveiLzwUsed in ValidateAnsi(Pdf).Issues);

// Zuverlässig auf beiden Compilern: Weisen Sie das Ergebnis zuerst einer lokalen Variablen zu.
var
  Vr: TPdfEValidationResult;
begin
  Vr := ValidateAnsi(Pdf);
  AssertTrue(pveiLzwUsed in Vr.Issues);
end;

Die inline geschriebene Form las unter FPC die Menge leer erscheinen, sodass jede Assertion, die ein Flag erwartete, fehlschlug, während der identische Delphi-Build erfolgreich durchlief. Die Ursache liegt im Unterschied darin, wie die beiden Compiler die Lebenszeit temporärer Funktionsergebnisse innerhalb größerer Ausdrücke verwalten: Delphi hält die temporäre Variable bis zum Ende der Anweisung am Leben, während FPC die Freigabe des Record-Temporärs mit dem Mengen-Membership-Operator überholen kann, der noch darauf liest. Die kaputte Form wirkt natürlich genug, um sich wieder einzuschleichen, selbst nachdem man das Verhalten einmal dokumentiert hat. Die Lösung ist mechanisch und sollte als Pauschalregel etabliert werden: Hängen Sie niemals einen Feldzugriff oder eine Mengenprüfung direkt an einen Funktionsaufruf an, der einen Record zurückgibt; weisen Sie das Ergebnis zuerst einer lokalen Variablen zu und lesen Sie dann das Feld. Das kostet eine Zeile und eliminiert eine ganze Klasse compilerabhängiger Flakiness

Warum akzeptiert Delphi einen Array-Index, den FPC nicht kompilieren will?

Die Kurzfassung lautet: dcc32 kompiliert einen außerhalb des Bereichs liegenden Index in ein Array mit festen Grenzen und liest oder schreibt bei standardmäßig deaktivierter Bereichsprüfung zur Laufzeit ohne jede Fehlermeldung im benachbarten Speicher, während FPC denselben Index bereits beim Kompilieren ablehnt. Die PDFium Component deklariert QuadPoints als ein 1-basiertes Array, TQuadrilateralPoint = array [1..4] of TPdfPoint, passend dazu, wie PDFs QuadPoints-Einträge üblicherweise nummeriert sind. Eine Demo-Schleife, die es mit dem reflexartigen 0-basierten Index füllt, scheint unter Delphi zu funktionieren

PDFium-Component-Diagramm eines 1-basierten PDF-Quad-Points-Arrays: Index 0 berührt unter dcc32 still das benachbarte Record-Feld, während FPC dieselbe Schleife mit einem Compile-Time-Range-Check-Fehler stoppt
Bei ausgeschalteter dcc32-Bereichsprüfung landet Index 0 stillschweigend auf dem benachbarten Record-Feld, während FPC dieselbe Schleife zur Compilezeit verwirft
var
  I: Integer;
begin
  for I := 0 to 3 do                       // falsch: das Array ist [1..4]
    Data.AttachmentPoints[I] := Corner[I]; // dcc32-Standard: kompiliert, Index 0
                                           // greift stillschweigend auf Nachbarspeicher zu
                                           // FPC: Bereichsprüfungsfehler beim Kompilieren
  for I := Low(TQuadrilateralPoint) to High(TQuadrilateralPoint) do
    Data.AttachmentPoints[I] := Corner[I - 1];  // korrekt auf beiden Compilern
end;

Der Delphi-Build ist ein falsches Positiv: Bei deaktivierter Bereichsprüfung, dem dcc32-Standard, landet der Index 0 auf dem Feld, das dem Array im Record vorangestellt ist, und die Demo scheint zu laufen. Derselbe Code unter Lazarus erzeugt sofort einen Bereichsprüfungsfehler zur Kompilierzeit durch den FPC. Die Annotations-Seite der QuadPoints behandelt der Artikel über QuadPoints-Annotationen. Zwei Lehren ergeben sich daraus. Erstens: Bevorzugen Sie Low() und High() gegenüber festen Literalen, wann immer ein Array-Typ nicht von Konstruktion wegen 0-basiert ist. Zweitens: Behandeln Sie einen FPC-Compile, oder mindestens einen Delphi-Build mit aktiviertem {$R+}, als zwingendes Erstlauf-Gate für jede neue Demo oder jeden Test: dcc32s Standardeinstellungen erzählen Ihnen von dieser Fehlerklasse nichts, und ein laufendes Programm ist kein Beweis für seine Korrektheit

Die TBytes-Zuweisung, die nur Delphi 13 akzeptiert

Die Kurzfassung lautet: Die Zuweisung eines als anonymes array of Byte deklarierten Feldes an eine TBytes-Variable kompiliert unter Delphi 13 (Compilerversion 37.0), scheitert jedoch unter Delphi 12 Athens und allen früheren Versionen mit der Meldung E2010 Incompatible types: 'TArray<Byte>' and 'Dynamic array'. Hierbei handelt es sich weniger um einen Unterschied zwischen Delphi und FPC, sondern um einen Unterschied zwischen Delphi und seinen eigenen Vorgängerversionen. Das Problem betrifft die Multi-Compiler-Codebasis auf die gleiche Weise: Der neueste Compiler akzeptiert eine Schreibweise, die ältere Versionen ablehnen

type
  TValidator = class
  private
    FBuffer: array of Byte;   // anonymer dynamischer Array-Typ
  end;

var
  OrigBytes: TBytes;
begin
  OrigBytes := FBuffer;          // nur Delphi 13; E2010 unter Delphi 12
                                 // Athens und früher
  OrigBytes := TBytes(FBuffer);  // kompiliert überall; identisches Byte-Layout,
                                 // sicherer Hard-Cast
end;

In die Falle tappt man leicht, wenn man unter Delphi 13 entwickelt, wo die implizite Konvertierung stillschweigend akzeptiert wird: Nutzer, dieselben Quellcode unter Delphi 12 oder älter kompilieren, bekommen stattdessen E2010. Die strukturelle Lösung ist entweder der oben gezeigte Hard-Cast, der sicher ist, da ein anonymes array of Byte und TBytes dasselbe Dynamic-Array-Layout nutzen, oder besser, das Feld von vornherein als benannten Typ wie TBytes zu deklarieren, sodass gar keine Konvertierung entsteht. Die prozessuale Lösung wiegt schwerer: Ein Konstrukt, das auf Ihrer neuesten Toolchain kompiliert, beweist nichts über die älteren Compiler, die Ihre Nutzer tatsächlich laufen lassen, und diese Problemkategorie ist unsichtbar, bis Sie gegen jede unterstützte Version bauen, denn ein lokaler 37.0-Build kann eine Nachsicht, die nur Delphi 13 zeigt, nicht aufspüren

Das AnsiString-Byte, das auf einem chinesischen Windows-System verschwindet

Die Kurzfassung lautet: Das Verketten eines rohen Bytes ab $80 in einen AnsiString mittels + kann unter Delphi stillschweigend dieses Byte durch ? ($3F) ersetzen, weil der Ausdruck einen impliziten AnsiString-zu-UnicodeString-zu-AnsiString-Round-Trip über die Systemcodepage nimmt. Typischerweise zeigt er sich in einem PDF/A-Test, der einen Namen mit einem isolierten $FE-Byte baut — das niemals ein legales UTF-8-Lead-Byte sein kann —, um zu prüfen, ob ein Validator Namen bemängelt, die gemäß ISO 19005-2 Abschnitt 6.1.8 kein gültiges UTF-8 darstellen

Diagramm des AnsiString-zu-UnicodeString-Rundlaufs, der ein rohes $FE-Byte auf einer CP936-chinesischen Windows-Maschine durch ein Fragezeichen ersetzt, daneben der sichere In-place-Byte-Patch in Delphi
Der implizite UnicodeString-Round-Trip ersetzt ein nicht abbildbares $FE-Byte durch $3F unter CP936, daher flickt der sichere Pfad das Byte an Ort und Stelle
var
  BadName: AnsiString;
begin
  // Unter Delphi mit einer Multi-Byte-Systemcodepage (beobachtet unter CP936)
  // vollzieht die Verkettung einen Round-Trip über UnicodeString. $FE ist keine
  // gültige CP936-Sequenz und wird zu '?' ($3F) konvertiert.
  BadName := '/Bad' + AnsiChar($FE) + 'Name';

  // Sicher: Mit einem ASCII-Platzhalter aufbauen, und das Byte dann direkt ersetzen.
  // Die Zuweisung über einen Index in einen bestehenden AnsiString vollzieht keinen Round-Trip.
  BadName := '/Bad' + #1 + 'Name';
  BadName[5] := AnsiChar($FE);
end;

Auf einem chinesischen Windows-System mit der Codepage 936 enthielt der verkettete String das Byte $FE überhaupt nicht, der Validator meldete also korrekt nichts, und der Test ging rot aus einem Grund, der mit dem Validator nichts zu tun hatte: Bekommt er eine PDF, die das Byte $FE wirklich enthält, meldet er das erwartete Flag. Die Beschädigung geschah im Delphi-Testprogramm, während der String-Ausdruck ausgewertet wurde, denn Delphis Unicode-first-Stringmodell konvertiert gemischte AnsiString-Ausdrücke über UnicodeString, und $FE ist in CP936 kein gültiges Lead-Byte, also ersetzt der Round-Trip es. Seien Sie ehrlich mit der Grenze hier: Auf einer Single-Byte-Westcodepage wie CP1252 übersteht derselbe Ausdruck es meist, genau deshalb versteckt sich dieses Problem auf den meisten Entwicklermaschinen und zeigt sich nur auf ostasiatischen Systemen oder lokalisierten CI-Runnern. Unsere Regel lautet nun: Binäre Testvektoren mit Bytes ab $80 niemals über AnsiString-Verkettung bauen; entweder die Bytes nach dem Feststehen des Strings an Ort und Stelle patchen, wie oben, oder den Vektor von Anfang an in TBytes konstruieren

Was ein dualer Compiler-Workflow standardmäßig prüfen sollte

Vier Fallen, ein Muster: Jeder Compiler erzählt Ihnen von einem anderen Teilbereich Ihrer Fehler. FPCs Bereichsanalyse zur Kompilierzeit erwischt einen außerhalb liegenden Index, den dcc32 klaglos ausführt, und dcc32s Unicode-Stringmodell legt eine Codepage-Abhängigkeit offen, die ein rein byte-orientierter FPC-Build niemals triggert. Die praktische Konsequenz: Keine der beiden grünen Pipelines reicht allein. Cross-Kompilierung ist nicht nur ein Portabilitäts-Checkbox-Häkchen, sie ist ein zweiter statischer Analysator und ein zweites Laufzeitmodell für denselben Quellcode, im selben Geist wie die defensiven Grenzprüfungen im Artikel über ABI- und Speicher-Sicherheitshärtung

Die festen Regeln, die aus diesen Fallen resultieren, sind kurz genug zum Auswendiglernen. Heften Sie Funktionsergebnis-Records an eine lokale Variable, bevor Sie Felder lesen. Iterieren Sie Arrays mit festen Grenzen mit Low() und High(), und führen Sie mindestens einen Bereichsgeprüften- oder FPC-Build aus, bevor Sie einer neuen Demo vertrauen. Casten Sie anonyme Dynamic-Array-Felder explizit oder deklarieren Sie sie mit benannten Typen, und bauen Sie vor dem Release die vollständige Compiler-Matrix. Halten Sie rohe High-Bytes vollständig aus AnsiString-Verkettungen heraus. Keine davon kostet messbare Mühe, sobald sie Gewohnheit sind, und jede schließt einen Fehlermodus, den ein Ein-Compiler-Workflow strukturell nicht sehen kann

Diese Regeln stammen aus der Pflege der PDFium Component, die denselben Object-Pascal-Quellcode für Delphi, C++Builder und FPC/Lazarus ausliefert