Article technique

Delphi vs FPC : 4 pièges de code PDF dans les builds PDFium

La même source Object Pascal peut se comporter différemment sous Delphi et FPC/Lazarus de quatre manières qui mordent régulièrement le code de PDFium Component : FPC libère les temporaires record résultats de fonction avant qu'un test d'appartenance in ait fini de les lire, dcc32 est livré avec la vérification de bornes coupée si bien que des index de tableau hors bornes lisent des données corrompues en silence, seul Delphi 13 accepte sans cast d'affecter un array of Byte anonyme à un TBytes, et la concaténation AnsiString de Delphi peut détruire des octets supérieurs ou égaux à $80 par un aller-retour de page de codes caché. Chacune produit une suite de tests au vert sur un compilateur et au rouge, ou pire, silencieusement fausse, sur l'autre

Si vous mettez en place un projet à deux compilateurs pour la première fois, le pas-à-pas du visualiseur Lazarus et FPC couvre le chemin heureux : paquets, chemins de recherche, et affichage d'une fenêtre de rendu à l'écran. Cet article est l'opposé d'un tutoriel. Il couvre ce qui a tendance à mal tourner une fois le chemin heureux en place, quand un changement qui passe sur un compilateur détone sur l'autre. Chaque piège ci-dessous vient avec une reproduction minimale, la cause racine, et la règle que nous avons retenue

Pourquoi un ensemble est-il lu comme vide sous FPC mais pas sous Delphi ?

La version en une phrase : FPC peut finaliser la variable temporaire qui porte le résultat record d'une fonction avant qu'une expression lisant un champ de ce résultat ait terminé, si bien que X in Func().Issues peut tester l'appartenance contre un ensemble déjà libéré alors que l'expression Delphi équivalente fonctionne. Les assertions de tests sont un endroit typique : un validateur PDF/E retourne un record dont le champ Issues est un ensemble de drapeaux de violation, et il est naturel d'inliner l'appel dans l'assertion

Diagramme montrant que Delphi garde en vie un enregistrement résultat de fonction PDFium temporaire jusqu'à la fin de l'instruction tandis que FPC le libère avant que l'opérateur in lise l'ensemble Issues, si bien que l'assertion ne passe que sous Delphi
Delphi garde l'enregistrement résultat de fonction temporaire en vie jusqu'à la fin de l'instruction, tandis que FPC peut le libérer avant que l'opérateur in ne lise l'ensemble Issues
// Peu fiable sous FPC : l'enregistrement temporaire de résultat de fonction
// peut être libéré avant que le test 'in' ne lise Issues
AssertTrue(pveiLzwUsed in ValidateAnsi(Pdf).Issues);

// Fiable sur les deux compilateurs : épinglez d'abord le résultat dans une variable locale
var
  Vr: TPdfEValidationResult;
begin
  Vr := ValidateAnsi(Pdf);
  AssertTrue(pveiLzwUsed in Vr.Issues);
end;

La forme inlinée lisait l'ensemble comme vide sous FPC, donc chaque assertion attendant un drapeau échouait, tandis que la build Delphi identique passait. La cause racine est une différence de gestion de la durée de vie des temporaires de résultat de fonction à l'intérieur d'expressions plus grandes : Delphi garde le temporaire en vie jusqu'à la fin de l'instruction, tandis que la libération du record temporaire par FPC peut faire la course à l'opérateur d'appartenance d'ensemble qui le lit encore. La forme cassée a l'air assez naturelle pour se glisser de retour même après avoir documenté le comportement une fois. Le correctif est mécanique et mérite d'être adopté comme règle générale : ne chaînez jamais un accès de champ ou un test d'ensemble directement sur un appel de fonction qui retourne un record ; affectez d'abord le résultat à une variable locale, puis lisez le champ. Cela coûte une ligne et supprime toute une classe de fragilité dépendante du compilateur

Pourquoi Delphi accepte-t-il un index de tableau que FPC refuse de compiler ?

La version en une phrase : dcc32 compile un index hors bornes dans un tableau à bornes fixes et, avec sa vérification de bornes désactivée par défaut, lit ou écrit la mémoire voisine à l'exécution sans aucune erreur, tandis que FPC refuse le même index à la compilation. PDFium Component déclare les quad points comme un tableau à base 1, TQuadrilateralPoint = array [1..4] of TPdfPoint, en accord avec la numérotation habituelle des entrées QuadPoints du PDF. Une boucle de démo qui le remplit avec l'index réflexif basé 0 semble fonctionner sous Delphi

Diagramme du PDFium Component d'un tableau de quad-points PDF indexé à partir de 1 où l'index 0 sous dcc32 touche silencieusement le champ d'enregistrement adjacent tandis que FPC arrête la même boucle avec une erreur de vérification d'intervalle à la compilation
Vérification de bornes désactivée sous dcc32, l'index 0 atterrit silencieusement sur le champ voisin de l'enregistrement, tandis que FPC rejette la même boucle à la compilation
var
  I: Integer;
begin
  for I := 0 to 3 do                       // erroné : le tableau est [1..4]
    Data.AttachmentPoints[I] := Corner[I]; // dcc32 par défaut : compile, index 0
                                           // touche silencieusement la mémoire adjacente
                                           // FPC : erreur de vérification de plage à la compilation
  for I := Low(TQuadrilateralPoint) to High(TQuadrilateralPoint) do
    Data.AttachmentPoints[I] := Corner[I - 1];  // correct sur les deux compilateurs
end;

La build Delphi est un faux positif : avec la vérification de bornes coupée, réglage par défaut de dcc32, l'index 0 atterrit sur le champ qui précède le tableau dans le record, et la démo semble tourner. Le même code sous Lazarus produit une erreur de compilation immédiate de vérification de bornes par FPC. Le côté annotation des quad points est couvert dans l'article sur les annotations à quad points. Deux leçons s'en dégagent. D'abord, préférez Low() et High() aux bornes littérales chaque fois que le type du tableau n'est pas basé 0 par construction. Ensuite, traitez une compilation FPC, ou au minimum une build Delphi avec {$R+} activé, comme une porte obligatoire au premier lancement de toute nouvelle démo ou tout nouveau test : les réglages par défaut de dcc32 ne vous diront rien de cette classe de bug, et un programme qui tourne n'est pas la preuve qu'il est correct

L'affectation de TBytes acceptée uniquement par Delphi 13

En résumé : affecter un champ déclaré sous la forme d'un array of Byte anonyme à une variable TBytes compile sous Delphi 13 (version de compilateur 37.0) mais échoue sous Delphi 12 Athens et toutes les versions antérieures avec le message E2010 Incompatible types: 'TArray<Byte>' and 'Dynamic array'. Il ne s'agit pas ici d'une divergence entre Delphi et FPC, mais plutôt d'une divergence entre Delphi et ses versions précédentes, qui affecte le code multi-compilateur de la même manière : le compilateur le plus récent accepte silencieusement une syntaxe que toutes les versions antérieures rejettent

type
  TValidator = class
  private
    FBuffer: array of Byte;   // type de tableau dynamique anonyme
  end;

var
  OrigBytes: TBytes;
begin
  OrigBytes := FBuffer;          // uniquement Delphi 13 ; E2010 sur Delphi 12
                                 // Athens et versions antérieures
  OrigBytes := TBytes(FBuffer);  // compile partout ; même disposition d'octets,
                                 // transtypage direct sûr
end;

Le piège est facile à rencontrer quand vous développez sous Delphi 13, où la conversion implicite est acceptée en silence : les utilisateurs qui compilent la même source sous Delphi 12 et antérieur obtiennent E2010 à la place. Le correctif structurel est soit le cast dur montré ci-dessus, sûr car un array of Byte anonyme et TBytes partagent une disposition de tableau dynamique identique, soit mieux, déclarer le champ avec un type nommé tel que TBytes dès le départ pour qu'aucune conversion ne survienne. Le correctif de processus importe plus : une construction qui compile sur votre toolchain la plus récente ne prouve rien sur les compilateurs plus anciens que vos utilisateurs exécutent réellement, et cette catégorie de problème est invisible tant que vous ne compilez pas contre chaque version prise en charge, car une build locale 37.0 ne peut pas attraper une tolérance propre à la 13

L'octet d'AnsiString qui disparaît sur une machine Windows chinoise

La version en une phrase : concaténer un octet brut supérieur ou égal à $80 dans un AnsiString avec + peut remplacer cet octet par ? ($3F) sous Delphi en silence, car l'expression prend un aller-retour implicite AnsiString vers UnicodeString vers AnsiString par la page de codes système. Cela se manifeste typiquement dans un test PDF/A qui construit un nom contenant un octet $FE isolé, jamais un octet de tête UTF-8 légal, pour vérifier qu'un validateur signale les noms qui ne sont pas de l'UTF-8 valide au sens de la clause 6.1.8 de ISO 19005-2

Diagramme de l'aller-retour AnsiString vers UnicodeString qui remplace un octet brut $FE par un point d'interrogation sur une machine Windows chinoise CP936, à côté du patch d'octet sûr sur place en Delphi
L'aller-retour UnicodeString implicite remplace un octet $FE inacheminable par $3F sous CP936, si bien que la voie sûre répare l'octet sur place
var
  BadName: AnsiString;
begin
  // Sous Delphi avec une page de codes système multi-octets (observé sur CP936),
  // la concaténation passe par UnicodeString et $FE, qui
  // n'étant pas une séquence CP936 valide, revient sous la forme '?' ($3F)
  BadName := '/Bad' + AnsiChar($FE) + 'Name';

  // Sûr : construisez avec un espace réservé ASCII, puis corrigez l'octet en place ;
  // une affectation indexée dans une AnsiString établie ne fait pas d'aller-retour
  BadName := '/Bad' + #1 + 'Name';
  BadName[5] := AnsiChar($FE);
end;

Sur un système Windows chinois configuré en page de codes 936, la chaîne concaténée ne contenait jamais de $FE du tout, donc le validateur ne rapportait correctement rien et le test passait au rouge pour une raison sans aucun rapport avec le validateur : donné un PDF contenant réellement l'octet $FE, il rapporte le drapeau attendu. La corruption est survenue à l'intérieur de l'exécutable de test Delphi pendant l'évaluation de l'expression de chaîne, car le modèle de chaînes Unicode-d'abord de Delphi convertit les expressions AnsiString mixtes via UnicodeString, et $FE n'est pas un octet de tête valide en CP936, donc l'aller-retour le remplace. Soyez honnête sur la frontière ici : sur une page de codes occidentale mono-octet telle que CP1252, la même expression survit généralement, et c'est exactement pourquoi ce problème se cache sur la plupart des machines de développement et ne surgit que sur les systèmes est-asiatiques ou les runners CI localisés. La règle que nous avons adoptée : ne construisez jamais des vecteurs de test binaires contenant des octets supérieurs ou égaux à $80 par concaténation AnsiString ; soit vous patchez les octets en place après que la chaîne est stabilisée, comme ci-dessus, soit vous construisez le vecteur en TBytes dès le départ

Ce qu'un flux de travail à double compilateur doit vérifier par défaut

Quatre pièges, un seul schéma : chaque compilateur vous parle d'un sous-ensemble différent de vos bugs. L'analyse de bornes à la compilation de FPC attrape un index hors bornes que dcc32 exécute en silence, et le modèle de chaînes Unicode de dcc32 expose une dépendance à la page de codes qu'une build FPC purement orientée octets ne déclenche jamais. La conséquence pratique, c'est qu'aucun pipeline vert ne suffit à lui seul. Cross-compiler n'est pas une simple case de portabilité, c'est un second analyseur statique et un second modèle d'exécution appliqués à la même source, dans le même esprit que les contrôles défensifs de frontière de l'article sur le durcissement ABI et sécurité mémoire

Les règles de fond qui se dégagent de ces pièges sont assez courtes pour être mémorisées. Affectez les records résultats de fonction à une variable locale avant de lire les champs. Parcourez les tableaux à bornes fixes avec Low() et High(), et lancez au moins une build à vérification de bornes ou FPC avant de faire confiance à une nouvelle démo. Convertissez explicitement (cast) les champs de tableaux dynamiques anonymes, ou déclarez-les avec des types nommés, et construisez la matrice complète de compilateurs avant chaque release. Tenez les octets bruts élevés hors de la concaténation AnsiString. Aucune de ces règles ne coûte un effort mesurable une fois devenues des habitudes, et chacune ferme un mode de défaillance qu'un flux mono-compilateur ne peut structurellement pas voir

Ces règles viennent de la maintenance de PDFium Component, qui livre la même source Object Pascal pour Delphi, C++Builder et FPC/Lazarus