O mesmo código-fonte Object Pascal pode se comportar de maneira diferente sob Delphi e FPC/Lazarus de quatro formas que rotineiramente afetam o código do PDFium Component: o FPC descarta registros temporários resultantes de funções antes que um teste de pertinência de conjunto in termine de lê-los, o dcc32 vem com a verificação de intervalo (range checking) desativada por padrão de modo que índices de array fora dos limites leiam lixo silenciosamente, apenas o Delphi 13 aceita a atribuição de um array of Byte anônimo para TBytes sem uma coerção (cast) de tipo, e a concatenação AnsiString do Delphi pode destruir bytes em valores iguais ou superiores a $80 por meio de uma conversão implícita de página de código. Cada um desses comportamentos produz uma suíte de testes que passa em um compilador e falha (ou, pior ainda, apresenta erro silencioso) no outro
Se você estiver configurando um projeto para compilador duplo pela primeira vez, o guia passo a passo do visualizador Lazarus e FPC aborda o caminho feliz: pacotes, caminhos de pesquisa e exibição de uma janela de renderização na tela. Este artigo é o oposto de um tutorial. Ele cobre o que tende a dar errado depois que o caminho feliz funciona, quando uma mudança que passa em um compilador detona no outro. Cada armadilha abaixo vem com uma reprodução mínima, a causa raiz, e a regra que nós padronizamos
Por que um conjunto é lido como vazio sob FPC, mas não no Delphi?
A versão resumida: o FPC pode finalizar a variável temporária que contém o resultado do registro de uma função antes que uma expressão que lê um campo desse resultado tenha terminado, de modo que X in Func().Issues possa testar a pertinência contra um conjunto que já foi liberado, enquanto a expressão equivalente no Delphi funciona. Asserções de teste são um lugar típico para esbarrar nisso: um validador PDF/E retorna um registro cujo campo Issues é um conjunto de sinalizadores de violação, e é natural trazer a chamada para dentro da asserção
// Não confiável sob o FPC: a temporária de registro do resultado da função
// pode ser liberada antes que o teste 'in' leia Issues
AssertTrue(pveiLzwUsed in ValidateAnsi(Pdf).Issues);
// Confiável em ambos os compiladores: fixe o resultado em uma local primeiro
var
Vr: TPdfEValidationResult;
begin
Vr := ValidateAnsi(Pdf);
AssertTrue(pveiLzwUsed in Vr.Issues);
end;
A forma em linha lia o conjunto como vazio sob FPC, de modo que cada asserção que esperava um sinalizador falhava, enquanto a compilação idêntica no Delphi passava. A causa raiz é uma diferença na forma como os dois compiladores gerenciam o tempo de vida de temporários resultantes de funções dentro de expressões maiores: o Delphi mantém a temporária viva até o final da instrução, enquanto o descarte da temporária do registro pelo FPC pode disputar corrida com o operador de pertinência de conjunto que ainda o está lendo. A forma quebrada parece natural o suficiente para se esgueirar de volta mesmo depois que você documentou o comportamento uma vez. A correção é mecânica e vale a pena ser adotada como regra geral: nunca encadeie um acesso a campo ou teste de conjunto diretamente a uma chamada de função que retorna um registro; atribua o resultado a uma variável local primeiro e depois leia o campo. Isso custa uma linha e elimina toda uma classe de instabilidade dependente do compilador
Por que o Delphi aceita um índice de array que o FPC se recusa a compilar?
A versão resumida: o dcc32 compila um índice fora da faixa em um array com limites fixos e, com sua verificação de intervalo padrão desativada, lê ou grava memória adjacente em tempo de execução sem gerar erros, enquanto o FPC rejeita o mesmo índice em tempo de compilação. O PDFium Component declara os pontos de quadrilátero como um array baseado em 1, TQuadrilateralPoint = array [1..4] of TPdfPoint, correspondendo a como as entradas QuadPoints do PDF costumam ser numeradas. Um loop de demonstração que o preenche com o índice reflexivo baseado em 0 aparenta funcionar sob Delphi
var
I: Integer;
begin
for I := 0 to 3 do // errado: o array é [1..4]
Data.AttachmentPoints[I] := Corner[I]; // padrão do dcc32: compila, o índice 0
// toca silenciosamente memória adjacente
// FPC: erro de verificação de intervalo em tempo de compilação
for I := Low(TQuadrilateralPoint) to High(TQuadrilateralPoint) do
Data.AttachmentPoints[I] := Corner[I - 1]; // correto em ambos os compiladores
end;
A compilação no Delphi é um falso positivo: com a verificação de intervalo desativada, que é o padrão do dcc32, o índice 0 cai em qualquer campo que preceda o array no registro, e a demonstração aparenta rodar. O mesmo código sob Lazarus produz um erro imediato de verificação de intervalo em tempo de compilação pelo FPC. O lado de anotações dos quad points é coberto no artigo de anotações com pontos quadriláteros. Duas lições vêm disso. Primeiro, prefira Low() e High() em vez de limites literais sempre que o tipo de array não for baseado em 0 por construção. Segundo, trate uma compilação FPC, ou no mínimo uma compilação Delphi com {$R+} ativado, como um gate obrigatório de primeira execução para qualquer demonstração ou teste novo: os padrões do dcc32 não informarão sobre essa classe de bug, e um programa que roda não é evidência de que ele está correto
A atribuição de TBytes que apenas o Delphi 13 aceita
A versão resumida: a atribuição de um campo declarado como array of Byte anônimo para uma variável TBytes compila no Delphi 13 (versão do compilador 37.0), mas falha no Delphi 12 Athens e em todas as versões anteriores com o erro E2010 Incompatible types: 'TArray<Byte>' and 'Dynamic array'. Esse caso não é tanto uma divisão Delphi versus FPC quanto uma divisão do Delphi versus o próprio passado dele, mas ele afeta a mesma base de código multi-compilador da mesma maneira: o compilador mais novo aceita silenciosamente uma construção que todos os outros rejeitam
type
TValidator = class
private
FBuffer: array of Byte; // tipo de array dinâmico anônimo
end;
var
OrigBytes: TBytes;
begin
OrigBytes := FBuffer; // apenas Delphi 13; E2010 no Delphi 12
// Athens e anteriores
OrigBytes := TBytes(FBuffer); // compila em todo lugar; mesmo layout de bytes,
// coerção forçada segura
end;
A armadilha é fácil de cair quando você desenvolve no Delphi 13, onde a conversão implícita é aceita silenciosamente: usuários compilando o mesmo código-fonte no Delphi 12 e anteriores recebem E2010 no lugar. A correção estrutural é ou a coerção forçada exibida acima, que é segura porque um array of Byte anônimo e o TBytes compartilham um layout de array dinâmico idêntico, ou melhor, declarar o campo como um tipo nomeado como TBytes desde o início, para que nenhuma conversão nunca surja. A correção de processo importa mais: uma construção que compila na sua cadeia de ferramentas mais recente não prova nada sobre os compiladores mais antigos que seus usuários realmente executam, e essa categoria de problema é invisível até você compilar contra todas as versões suportadas, porque uma compilação 37.0 local não consegue capturar uma flexibilidade exclusiva da versão 13
O byte AnsiString que desaparece em uma máquina Windows chinesa
A versão resumida: concatenar um byte bruto igual ou superior a $80 em uma AnsiString com + pode substituir silenciosamente esse byte por ? ($3F) sob o Delphi, porque a expressão realiza uma round-trip implícita de AnsiString para UnicodeString e de volta para AnsiString através da página de código do sistema. Ele tipicamente aparece em um teste de PDF/A que constrói um nome contendo um byte $FE isolado — que nunca é um byte de cabeçalho UTF-8 legal — para verificar que um validador sinaliza nomes que não são UTF-8 válidos conforme a ISO 19005-2 cláusula 6.1.8
var
BadName: AnsiString;
begin
// No Delphi com uma página de código de sistema multibyte (observado no CP936),
// a concatenação vai e volta por UnicodeString, e o $FE, que
// não é uma sequência CP936 válida, retorna como '?' ($3F)
BadName := '/Bad' + AnsiChar($FE) + 'Name';
// Seguro: monte com um placeholder ASCII, depois corrija o byte no lugar;
// uma atribuição indexada em uma AnsiString já estabelecida não vai e volta
BadName := '/Bad' + #1 + 'Name';
BadName[5] := AnsiChar($FE);
end;
Em um sistema Windows chinês executando a página de código 936, a string concatenada nunca conteve o byte $FE, de modo que o validador corretamente não reportava nada e o teste ficava vermelho por um motivo que não tinha nada a ver com o validador: dado um PDF que genuinamente contém o byte $FE, ele reporta o sinalizador esperado. A corrupção acontecia dentro do executável de testes do Delphi enquanto a expressão de string estava sendo avaliada, porque o modelo de string prioritariamente Unicode do Delphi converte expressões AnsiString mistas através de UnicodeString, e o $FE não é um byte de cabeçalho válido no CP936, de modo que a round-trip o substitui. Seja honesto sobre o limite aqui: em uma página de código ocidental de byte único, como o CP1252, a mesma expressão costuma sobreviver, o que é exatamente por que esse problema se esconde na maioria das máquinas de desenvolvimento e aparece só em sistemas do Leste Asiático ou runners de CI localizados. A regra que adotamos: nunca construa vetores de teste binários contendo bytes iguais ou superiores a $80 por concatenação AnsiString; ou corrija os bytes no lugar depois que a string estiver definida, como acima, ou construa o vetor em TBytes desde o início
O que um fluxo de trabalho com compilador duplo deve verificar por padrão
Quatro armadilhas, um padrão: cada compilador informa sobre um subconjunto diferente dos seus bugs. A análise de intervalo em tempo de compilação do FPC captura um índice fora dos limites que o dcc32 executa silenciosamente, e o modelo de string Unicode do dcc32 expõe uma dependência de página de código que uma compilação FPC puramente orientada a bytes nunca aciona. A consequência prática é que nenhuma das duas esteiras verdes é suficiente de forma isolada. A compilação cruzada não é apenas uma caixa de seleção de portabilidade — ela é um segundo analisador estático e um segundo modelo de tempo de execução aplicado ao mesmo código-fonte, no mesmo espírito das verificações defensivas de limites descritas no artigo sobre robustecimento de ABI e segurança de memória
As regras permanentes que resultam dessas armadilhas são curtas o suficiente para serem memorizadas. Fixe registros resultantes de funções a uma variável local antes de ler campos. Percorra arrays de limites fixos com Low() e High(), e execute pelo menos uma compilação com verificação de intervalo ou no FPC antes de confiar em qualquer demonstração nova. Faça coerção explícita dos campos de array dinâmico anônimo, ou declare-os com tipos nomeados, e compile em toda a matriz de compiladores antes do lançamento. Mantenha bytes brutos altos totalmente fora da concatenação de AnsiString. Nenhuma delas custa esforço mensurável depois que viram hábitos, e cada uma fecha um modo de falha que um fluxo de trabalho de compilador único estruturalmente não consegue enxergar
Essas regras vêm da manutenção do PDFium Component, que fornece o mesmo código-fonte Object Pascal para Delphi, C++Builder e FPC/Lazarus