Lo stesso codice sorgente Object Pascal può comportarsi in modo diverso tra Delphi e FPC/Lazarus in quattro ambiti che interessano ripetutamente il codice del componente PDFium: FPC elimina le variabili temporanee dei record restituiti dalle funzioni prima che un test di appartenenza in termini di leggerle, dcc32 viene distribuito con il controllo dell'intervallo disattivato per cui gli indici di array fuori limite leggono silenziosamente dati non validi, solo Delphi 13 accetta l'assegnazione di un array anonimo array of Byte a TBytes senza un cast, e la concatenazione AnsiString di Delphi può corrompere i byte uguali o superiori a $80 tramite una conversione di tabella codici nascosta. Ciascuna di queste problematiche produce test di successo su un compilatore e di fallimento, o peggio, silenziosamente errati, sull'altro
Se stai configurando un progetto a doppio compilatore per la prima volta, la guida al visualizzatore Lazarus e FPC illustra il percorso felice: pacchetti, percorsi di ricerca e una finestra di rendering a schermo. Questo articolo è l'opposto di un tutorial. Copre quello che tende a andare storto dopo che il percorso felice funziona, quando una modifica che passa su un compilatore esplode sull'altro. Ogni trappola qui sotto arriva con una riproduzione minima, la causa principale, e la regola che abbiamo standardizzato
Perché un set viene letto come vuoto sotto FPC ma non in Delphi?
In breve: FPC può finalizzare la variabile temporanea contenente il record restituito da una funzione prima del termine di un'espressione che legge un campo di quel risultato, per cui X in Func().Issues può verificare l'appartenenza rispetto a un set già rilasciato, mentre l'espressione equivalente in Delphi funziona correttamente. Le asserzioni di test sono il posto tipico dove ci si imbatte: un validatore PDF/E restituisce un record il cui campo Issues è un set di flag di violazione, ed è naturale mettere la chiamata in linea nell'asserzione
// Inaffidabile sotto FPC: la temporanea del record risultato di funzione
// può essere rilasciata prima che il test 'in' legga Issues
AssertTrue(pveiLzwUsed in ValidateAnsi(Pdf).Issues);
// Affidabile su entrambi i compilatori: blocca prima il risultato in una locale
var
Vr: TPdfEValidationResult;
begin
Vr := ValidateAnsi(Pdf);
AssertTrue(pveiLzwUsed in Vr.Issues);
end;
La forma in linea leggeva il set come vuoto sotto FPC, per cui ogni asserzione che si aspettava un flag falliva, mentre la build identica in Delphi andava a buon fine. La causa risiede in una differenza nel modo in cui i due compilatori gestiscono la durata dei temporanei risultato-funzione dentro espressioni più ampie: Delphi mantiene in vita la variabile temporanea fino alla fine dell'istruzione, mentre lo smaltimento del record temporaneo da parte di FPC può fare a gara con l'operatore di appartenenza al set che lo sta ancora leggendo. La forma errata sembra così naturale che torna a insinuarsi anche dopo aver documentato il comportamento una volta. La correzione è meccanica e merita di essere adottata come regola generale: non concatenare mai l'accesso a un campo o il test di un set direttamente a una chiamata di funzione che restituisce un record; assegna prima il risultato a una variabile locale, quindi leggi il campo. Costa una sola riga di codice ed elimina un'intera classe di comportamenti instabili legati al compilatore
Perché Delphi accetta un indice di array che FPC rifiuta di compilare?
In breve: dcc32 compila un indice fuori intervallo in un array a limiti fissi e, con il controllo dell'intervallo disattivato per impostazione predefinita, legge o scrive la memoria adiacente in fase di esecuzione senza generare errori, mentre FPC rifiuta lo stesso indice in fase di compilazione. Il PDFium Component dichiara i punti quadrilaterali come un array a base 1, TQuadrilateralPoint = array [1..4] of TPdfPoint, allineandosi a come le voci QuadPoints dei PDF sono di solito numerate. Un ciclo di demo che lo riempie con il consueto indice a base 0 sembra funzionare sotto Delphi
var
I: Integer;
begin
for I := 0 to 3 do // errato: l'array è [1..4]
Data.AttachmentPoints[I] := Corner[I]; // default dcc32: compila, indice 0
// tocca silenziosamente la memoria adiacente
// FPC: errore di controllo dell'intervallo in fase di compilazione
for I := Low(TQuadrilateralPoint) to High(TQuadrilateralPoint) do
Data.AttachmentPoints[I] := Corner[I - 1]; // corretto su entrambi i compilatori
end;
La build in Delphi è un falso positivo: con il controllo dell'intervallo disattivato (impostazione predefinita di dcc32), l'indice 0 atterra su qualunque campo preceda l'array nel record, e la demo sembra girare. Lo stesso codice sotto Lazarus produce un errore immediato di controllo dell'intervallo da parte di FPC in fase di compilazione. Il lato annotazioni dei quad points è trattato nell'articolo sulle annotazioni quad-points. Da qui emergono due lezioni. Primo, preferisci Low() e High() rispetto ai limiti letterali ogni volta che il tipo dell'array non è a base 0 per costruzione. Secondo, tratta la compilazione in FPC, o come minimo una build in Delphi con {$R+} attivato, come un varco obbligatorio al primo avvio per ogni nuova demo o test: le impostazioni predefinite di dcc32 non ti diranno niente su questa classe di bug, e un programma che gira non è la prova che sia corretto
L'assegnazione TBytes accettata solo da Delphi 13
In breve: l'assegnazione di un campo dichiarato come array of Byte anonimo a una variabile TBytes viene compilata in Delphi 13 (versione del compilatore 37.0) ma fallisce in Delphi 12 Athens e in tutte le versioni precedenti con l'errore E2010 Incompatible types: 'TArray<Byte>' and 'Dynamic array'. Non si tratta di una differenza tra Delphi e FPC, ma tra Delphi e le sue versioni precedenti, che incide comunque sul codice multicompilatore: il compilatore più recente accetta una sintassi che tutte le altre versioni rifiutano
type
TValidator = class
private
FBuffer: array of Byte; // tipo di array dinamico anonimo
end;
var
OrigBytes: TBytes;
begin
OrigBytes := FBuffer; // solo Delphi 13; E2010 su Delphi 12
// Athens e versioni precedenti
OrigBytes := TBytes(FBuffer); // compila ovunque; stesso layout di byte,
// hard cast sicuro
end;
La trappola è facile quando sviluppi su Delphi 13, dove la conversione implicita viene accettata in silenzio: gli utenti che compilano lo stesso sorgente su Delphi 12 e versioni precedenti ottengono invece E2010. La correzione strutturale è o il cast esplicito mostrato sopra, sicuro poiché un array of Byte anonimo e TBytes condividono lo stesso layout di array dinamico, o meglio ancora dichiarare fin da subito il campo con un tipo denominato come TBytes, così la conversione non sorge mai. La correzione di processo conta di più: un costrutto che compila sulla tua toolchain più recente non dimostra niente sui compilatori meno recenti che i tuoi utenti usano davvero, e questa categoria di problemi è invisibile finché non compili contro ogni versione supportata, perché una build 37.0 locale non può cogliere una tolleranza presente solo nella versione 13
Il byte AnsiString che scompare su un sistema Windows in lingua cinese
In breve: concatenare un byte grezzo uguale o superiore a $80 in una AnsiString con + può sostituire silenziosamente quel byte con ? ($3F) sotto Delphi, perché l'espressione subisce un round-trip implicito da AnsiString a UnicodeString e ritorno ad AnsiString attraverso la tabella codici di sistema. Di norma emerge in un test PDF/A che costruisce un nome contenente un byte $FE isolato, mai valido come lead byte UTF-8, per verificare che un validatore segnali i nomi non validi come UTF-8 secondo ISO 19005-2 clausola 6.1.8
var
BadName: AnsiString;
begin
// Su Delphi con una tabella codici di sistema multibyte (osservato su CP936),
// la concatenazione passa da UnicodeString e $FE, il quale
// non è una sequenza CP936 valida, torna come '?' ($3F)
BadName := '/Bad' + AnsiChar($FE) + 'Name';
// Sicuro: costruisci con un segnaposto ASCII, poi correggi il byte sul posto;
// l'assegnazione indicizzata in una AnsiString già definita non passa da UnicodeString
BadName := '/Bad' + #1 + 'Name';
BadName[5] := AnsiChar($FE);
end;
Su un sistema Windows in lingua cinese con tabella codici 936, la stringa concatenata non conteneva affatto il byte $FE, quindi il validatore correttamente non segnalava nulla e il test andava in rosso per una ragione che non c'entrava con il validatore: dato un PDF che contiene davvero il byte $FE, riporta il flag previsto. La corruzione avveniva dentro l'eseguibile di test in Delphi durante la valutazione dell'espressione stringa, poiché il modello di stringhe incentrato su Unicode di Delphi converte le espressioni AnsiString miste tramite UnicodeString, e $FE non è un lead byte valido in CP936, quindi il round-trip lo sostituisce. Sii onesto sui limiti: su una tabella codici occidentale a byte singolo come CP1252 la stessa espressione di solito sopravvive, ed è esattamente perché questo problema si nasconde sulla maggior parte dei computer di sviluppo ed emerge solo su sistemi dell'Asia orientale o su runner CI localizzati. La regola che abbiamo adottato: non costruire mai vettori di test binari contenenti byte uguali o superiori a $80 tramite concatenazione AnsiString; o modifichi i byte sul posto dopo che la stringa è stata definita, come sopra, o costruisci il vettore in TBytes fin dall'inizio
Cosa dovrebbe verificare per impostazione predefinita un flusso di lavoro a doppio compilatore
Quattro trappole, un solo pattern: ciascun compilatore ti parla di un diverso sottoinsieme dei tuoi bug. L'analisi degli intervalli in fase di compilazione di FPC coglie un indice fuori limite che dcc32 esegue in silenzio, e il modello di stringhe Unicode di dcc32 espone una dipendenza dalla tabella codici che una build FPC focalizzata sui byte non attiva mai. La conseguenza pratica è che nessuna pipeline verde basta da sola. La compilazione incrociata non è solo una casella di portabilità, è un secondo analizzatore statico e un secondo modello di esecuzione applicati allo stesso sorgente, nello stesso spirito dei controlli difensivi ai confini descritti nell'articolo sul consolidamento della sicurezza della memoria e delle ABI
Le regole derivate da questi incidenti sono semplici da ricordare. Assegna i record restituiti dalle funzioni a una variabile locale prima di leggerne i campi. Itera gli array a limiti fissi tramite Low() e High(), ed esegui almeno una build con controllo dell'intervallo o in FPC prima di fidarti di una nuova demo. Esegui il cast esplicito dei campi array dinamici anonimi, o dichiarali con tipi denominati, e compila sulla matrice completa dei compilatori prima del rilascio. Tieni i byte alti grezzi del tutto fuori dalla concatenazione AnsiString. Nessuna di queste pratiche costa uno sforzo misurabile una volta divenute abitudine, ed ognuna chiude una modalità di fallimento che un flusso a compilatore singolo strutturalmente non può vedere
Queste regole arrivano dalla manutenzione del PDFium Component, che distribuisce lo stesso sorgente Object Pascal per Delphi, C++Builder e FPC/Lazarus