Artículo técnico

Delphi vs FPC: 4 trampas ocultas de código PDF con PDFium

El mismo código fuente de Object Pascal puede comportarse de manera diferente en Delphi y en FPC/Lazarus de cuatro formas que afectan repetidamente al código de PDFium Component: FPC desecha los registros temporales resultantes de funciones antes de que una prueba de pertenencia in termine de leerlos, dcc32 se distribuye con la verificación de rango desactivada por lo que los índices de matriz fuera de los límites leen basura silenciosamente, solo Delphi 13 acepta la asignación de una matriz anónima array of Byte a TBytes sin un cast, y la concatenación de AnsiString en Delphi puede destruir bytes iguales o superiores a $80 a través de un viaje de ida y vuelta oculto por la página de códigos. Cada una de ellas produce una suite de pruebas que está en verde en un compilador y en rojo, o peor aún, que es silenciosamente incorrecta en el otro

Si está configurando un proyecto de compilador dual por primera vez, el tutorial del visor Lazarus y FPC cubre el camino feliz: paquetes, rutas de búsqueda y cómo colocar una ventana de renderizado en pantalla. Este artículo es lo opuesto a un tutorial. Cubre lo que suele salir mal después de que el camino feliz funciona, cuando un cambio que pasa en un compilador detona en el otro. Cada trampa a continuación viene con una reproducción mínima, la causa raíz y la regla que estandarizamos

¿Por qué un conjunto se lee vacío bajo FPC pero no en Delphi?

La versión de una sola frase: FPC puede finalizar la variable temporal que contiene el resultado de registro de una función antes de que haya terminado una expresión que lee un campo de ese resultado, por lo que X in Func().Issues puede probar la pertenencia a un conjunto ya liberado mientras que la expresión equivalente en Delphi funciona. Las aserciones de pruebas son un lugar típico donde toparse con esto: un validador de PDF/E devuelve un registro cuyo campo Issues es un conjunto de banderas de infracción, y es natural poner la llamada en línea dentro de la aserción

Diagrama que muestra Delphi manteniendo vivo temporalmente un registro de resultado de función PDFium hasta que la sentencia termina mientras FPC lo libera antes de que el operador in lea el conjunto Issues, así que la aserción solo pasa bajo Delphi
Delphi mantiene vivo el temporal del registro de resultado de función hasta que termina la instrucción, mientras que FPC puede liberarlo antes de que el operador in lea el conjunto Issues
// No fiable bajo FPC: el temporal del registro del resultado de la función
// puede liberarse antes de que la prueba 'in' lea Issues
AssertTrue(pveiLzwUsed in ValidateAnsi(Pdf).Issues);

// Fiable en ambos compiladores: fija primero el resultado a una variable local
var
  Vr: TPdfEValidationResult;
begin
  Vr := ValidateAnsi(Pdf);
  AssertTrue(pveiLzwUsed in Vr.Issues);
end;

La forma en línea leyó el conjunto como vacío bajo FPC, por lo que falló cada aserción que esperaba una bandera, mientras que la compilación idéntica de Delphi se aprobó. La causa raíz es una diferencia en cómo los dos compiladores administran la vida útil de los temporales resultantes de funciones dentro de expresiones más grandes: Delphi mantiene vivo el temporal hasta el final de la instrucción, mientras que la eliminación del registro temporal por parte de FPC puede entrar en conflicto con el operador de pertenencia al conjunto que todavía lo está leyendo. La forma rota parece lo bastante natural como para colarse de nuevo incluso después de haber documentado el comportamiento una vez. La solución es mecánica y vale la pena adoptarla como regla general: nunca encadene un acceso a un campo o una prueba de pertenencia directamente a una llamada de función que devuelva un registro; asigne el resultado a una variable local primero, luego lea el campo. Cuesta una sola línea y elimina toda una clase de inestabilidad dependiente del compilador

¿Por qué Delphi acepta un índice de matriz que FPC se niega a compilar?

La versión de una sola frase: dcc32 compila un índice fuera de rango en una matriz de límites fijos y, con su verificación de rango predeterminada desactivada, lee o escribe memoria adyacente en tiempo de ejecución sin ningún error, mientras que FPC rechaza el mismo índice en tiempo de compilación. El PDFium Component declara los puntos del cuadrilátero como una matriz basada en 1, TQuadrilateralPoint = array [1..4] of TPdfPoint, coincidiendo con cómo se suelen numerar las entradas QuadPoints de PDF. Un bucle de demostración que la rellena con el índice reflexivo basado en 0 parece funcionar bajo Delphi

Diagrama de PDFium Component de un array de quad-points PDF basado en uno donde el índice 0 bajo dcc32 toca en silencio el campo adyacente del registro mientras FPC detiene el mismo bucle con un error de comprobación de rango en compilación
Con la comprobación de rangos de dcc32 desactivada, el índice 0 aterriza silenciosamente en el campo vecino del registro, mientras que FPC rechaza el mismo bucle en tiempo de compilación
var
  I: Integer;
begin
  for I := 0 to 3 do                       // incorrecto: la matriz es [1..4]
    Data.AttachmentPoints[I] := Corner[I]; // dcc32 predeterminado: compila, índice 0
                                           // toca en silencio la memoria adyacente
                                           // FPC: error de verificación de rango en tiempo de compilación
  for I := Low(TQuadrilateralPoint) to High(TQuadrilateralPoint) do
    Data.AttachmentPoints[I] := Corner[I - 1];  // correcto en ambos compiladores
end;

La compilación de Delphi es un falso positivo: con la verificación de rango desactivada (que es el valor predeterminado de dcc32), el índice 0 aterriza en cualquier campo que preceda a la matriz en el registro, y la demostración parece ejecutarse. El mismo código bajo Lazarus produce un error de verificación de rango inmediato en tiempo de compilación por parte de FPC. El lado de anotaciones de los quad points se cubre en el artículo sobre anotaciones con QuadPoints. Dos lecciones salen de esto. Primero, prefiera Low() y High() sobre límites literales siempre que el tipo de matriz no esté basado en 0 por construcción. Segundo, trate una compilación de FPC, o como mínimo una compilación de Delphi con {$R+} habilitada, como una puerta obligatoria de primera ejecución para cualquier demostración o prueba nueva: los valores predeterminados de dcc32 no le informarán sobre esta clase de error, y un programa que se ejecute no es evidencia de que sea correcto

La asignación de TBytes que solo acepta Delphi 13

La versión de una sola frase: asignar un campo declarado como una matriz anónima array of Byte a una variable TBytes se compila en Delphi 13 (versión del compilador 37.0) pero falla en Delphi 12 Athens y en todas las versiones anteriores con E2010 Incompatible types: 'TArray<Byte>' and 'Dynamic array'. Esta división no es tanto entre Delphi y FPC, sino más bien entre Delphi y su propio pasado, pero afecta al mismo código base multi-compilador de la misma manera: el compilador más nuevo acepta silenciosamente una construcción que todos los demás rechazan

type
  TValidator = class
  private
    FBuffer: array of Byte;   // tipo de matriz dinámica anónimo
  end;

var
  OrigBytes: TBytes;
begin
  OrigBytes := FBuffer;          // solo Delphi 13; E2010 en Delphi 12
                                 // Athens y anteriores
  OrigBytes := TBytes(FBuffer);  // compila en todas partes; mismo diseño de bytes,
                                 // cast directo seguro
end;

La trampa es fácil de caer cuando desarrolla en Delphi 13, donde la conversión implícita se acepta en silencio: los usuarios que compilan el mismo código fuente en Delphi 12 y anteriores obtienen E2010 en su lugar. La solución estructural es o bien el cast directo (hard cast) mostrado arriba, que es seguro porque un array of Byte anónimo y TBytes comparten un diseño de matriz dinámica idéntico, o mejor aún, declarar el campo como un tipo con nombre como TBytes en primer lugar para que nunca surja la conversión. La solución del proceso importa más: una construcción que se compila en su cadena de herramientas más nueva no demuestra nada sobre los compiladores más antiguos que realmente ejecutan sus usuarios, y esta categoría de problema es invisible hasta que compila contra cada versión compatible, porque una compilación local 37.0 no puede detectar una tolerancia exclusiva de la versión 13

El byte de AnsiString que desaparece en una máquina Windows en chino

La versión de una sola frase: concatenar un byte sin procesar igual o superior a $80 en una AnsiString con + puede reemplazar silenciosamente ese byte con ? ($3F) bajo Delphi, porque la expresión realiza un viaje de ida y vuelta implícito de AnsiString a UnicodeString y de nuevo a AnsiString a través de la página de códigos del sistema. Suele aflorar en una prueba de PDF/A que construye un nombre que contiene un byte $FE aislado, que nunca es un byte inicial UTF-8 legal, para verificar que un validador marca los nombres que no son UTF-8 válidos según la cláusula 6.1.8 de ISO 19005-2

Diagrama del viaje de ida y vuelta AnsiString a UnicodeString que sustituye un byte $FE en bruto por un signo de interrogación en una máquina Windows china CP936, junto al parche de byte seguro in situ en Delphi
El viaje de ida y vuelta implícito de UnicodeString sustituye un byte $FE no maleable por $3F bajo CP936, de modo que la vía segura parchea el byte in situ
var
  BadName: AnsiString;
begin
  // En Delphi con una página de códigos del sistema multibyte (observada en CP936),
  // la concatenación hace un viaje de ida y vuelta a través de UnicodeString y $FE, que
  // no es una secuencia CP936 válida, vuelve como '?' ($3F)
  BadName := '/Bad' + AnsiChar($FE) + 'Name';

  // Seguro: construye con un marcador ASCII, luego parchea el byte en su lugar;
  // la asignación indexada en una AnsiString establecida no hace el viaje de ida y vuelta
  BadName := '/Bad' + #1 + 'Name';
  BadName[5] := AnsiChar($FE);
end;

En un sistema Windows en chino que ejecutaba la página de códigos 936, la cadena concatenada nunca contuvo $FE en absoluto, por lo que el validador correctamente no informó de nada y la prueba se puso en rojo por una razón que no tenía nada que ver con el validador: dado un PDF que contiene genuinamente el byte $FE, reporta la bandera esperada. La corrupción ocurrió dentro del ejecutable de prueba de Delphi mientras se evaluaba la expresión de la cadena, porque el modelo de cadena de Delphi que prioriza Unicode convierte expresiones AnsiString mezcladas a través de UnicodeString, y $FE no es un byte inicial válido en CP936 por lo que el viaje de ida y vuelta lo reemplaza. Seamos honestos sobre el límite aquí: en una página de códigos occidental de un solo byte como CP1252, la misma expresión generalmente sobrevive, que es exactamente la razón por la cual este problema se oculta en la mayoría de las máquinas de desarrollo y aflora solo en sistemas de Asia Oriental o en ejecutores de CI localizados. La regla que adoptamos: nunca construya vectores de prueba binarios que contengan bytes iguales o superiores a $80 mediante la concatenación de AnsiString; o parchee los bytes en su lugar después de que la cadena se haya establecido, como se describió anteriormente, o construya el vector en TBytes desde el principio

Qué debería verificar por defecto un flujo de trabajo de compilador dual

Cuatro trampas, un patrón: cada compilador le informa sobre un subconjunto de sus errores. El análisis de rango en tiempo de compilación de FPC caza un índice fuera de los límites que dcc32 ejecuta en silencio, y el modelo de cadena Unicode de dcc32 expone una dependencia de la página de códigos que una compilación pura de FPC orientada a bytes nunca activa. La consecuencia práctica es que ninguna de las tuberías en verde es suficiente por sí sola. La compilación cruzada no es solo una casilla de verificación de portabilidad, es un segundo analizador estático y un segundo modelo de tiempo de ejecución aplicados a la misma fuente, con el mismo espíritu que las comprobaciones defensivas de límites en el artículo sobre el endurecimiento de la seguridad de la memoria y la ABI

Las reglas permanentes que se desprenden de estas trampas son lo suficientemente cortas como para memorizarlas. Fije los registros de resultados de funciones a una variable local antes de leer los campos. Itere las matrices de límites fijos con Low() y High(), y ejecute al menos una compilación con verificación de rango o de FPC antes de confiar en cualquier demostración nueva. Haga el cast de los campos de matriz dinámica anónima de forma explícita, o declárelos con tipos con nombre, y compile la matriz completa de compiladores antes del lanzamiento. Mantenga los bytes altos sin procesar fuera de la concatenación de AnsiString por completo. Ninguna de estas cuesta un esfuerzo medible una vez que son hábitos, y cada una cierra un modo de fallo que un flujo de trabajo de un solo compilador estructuralmente no puede ver

Estas reglas vienen del mantenimiento del PDFium Component, que distribuye el mismo código fuente de Object Pascal para Delphi, C++Builder y FPC/Lazarus