Техническая статья

Delphi против FPC: 4 скрытые ловушки в кодовой базе PDFium

Один и тот же исходный код на Object Pascal может вести себя по-разному в Delphi и FPC/Lazarus. Существует четыре ключевых архитектурных различия, которые регулярно затрагивают кодовую базу PDFium Component: FPC уничтожает временные переменные записей, возвращаемых функциями, до завершения проверки членства in; компилятор dcc32 по умолчанию собирает код без проверки диапазонов, из-за чего выход индекса за границы массива молча читает мусор; только в Delphi 13 разрешено присваивать анонимный тип array of Byte переменной TBytes без явного приведения; а конкатенация AnsiString в Delphi может искажать байты со значениями от $80 и выше из-за скрытого преобразования кодовых страниц. Каждая из этих ловушек приводит к тому, что тесты успешно проходят в одном компиляторе и завершаются с ошибками (или, что хуже, работают неверно без ошибок) в другом

Если вы впервые настраиваете проект с двумя компиляторами, руководство по вьюеру на Lazarus и FPC описывает протоптанную дорожку: пакеты, пути поиска и вывод окна рендеринга на экран. Эта статья — противоположность туториалу. Она о том, что идёт не так после того, как дорожка заработала, когда изменение, проходящее на одном компиляторе, детонирует на другом. Каждая ловушка ниже снабжена минимальной репродукцией, первопричиной и правилом, которое мы сделали стандартом

Почему проверка множества возвращает ложь на FPC, но работает в Delphi?

В одном предложении: FPC может финализировать временную переменную, хранящую запись-результат функции, до того, как закончилось вычисление выражения, читающего поле этой записи, так что X in Func().Issues может проверять вхождение в уже освобождённое множество, тогда как эквивалентное выражение в Delphi работает. Типичное место, где это встречается, — тестовые проверки: валидатор PDF/E возвращает запись, поле Issues которой — множество флагов нарушений, и инлайнить вызов прямо в проверке естественно

Диаграмма: Delphi держит временную запись-результат функции PDFium живой до конца оператора, тогда как FPC освобождает её до того, как оператор in прочитает набор Issues, поэтому утверждение проходит только под Delphi
Delphi держит временную запись результата функции живой до конца оператора, тогда как FPC может освободить её прежде, чем оператор in прочтёт множество Issues
// Ненадёжно под FPC: временная запись результата функции
// может быть освобождена до того, как проверка 'in' прочитает Issues
AssertTrue(pveiLzwUsed in ValidateAnsi(Pdf).Issues);

// Надёжно в обоих компиляторах: сначала закрепите результат в локальной переменной
var
  Vr: TPdfEValidationResult;
begin
  Vr := ValidateAnsi(Pdf);
  AssertTrue(pveiLzwUsed in Vr.Issues);
end;

Инлайн-форма считывала множество как пустое под FPC, так что каждая проверка, ожидающая флаг, падала, а идентичная сборка Delphi проходила. Первопричина — разница в том, как компиляторы управляют временем жизни временных записей-результатов функций внутри больших выражений: Delphi держит временную переменную живой до конца оператора, а освобождение временной записи в FPC может обогнать оператор проверки вхождения, который её ещё читает. Сломанная форма выглядит достаточно естественно, чтобы пролезть обратно, даже если вы однажды задокументировали это поведение. Фикс механический и стоит сделать общим правилом: никогда не прицепляйте обращение к полю или проверку множества напрямую к вызову функции, возвращающей запись; сперва присвойте результат локальной переменной, потом читайте поле. Это стоит одну строку и убирает целый класс зависящей от компилятора нестабильности

Почему Delphi пропускает индекс массива, который FPC отказывается компилировать?

В одном предложении: dcc32 компилирует индекс вне границ для массива с фиксированными границами, и с выключенной по умолчанию проверкой диапазонов читает или пишет соседнюю память в рантайме без всякой ошибки, тогда как FPC отвергает тот же индекс на этапе компиляции. PDFium Component объявляет quad points как массив с базой 1, TQuadrilateralPoint = array [1..4] of TPdfPoint, в духе того, как записи QuadPoints в PDF обычно нумеруются. Демо-цикл, заполняющий его рефлексивным 0-базным индексом, под Delphi выглядит работающим

Диаграмма PDFium Component: массив quad-points PDF с основанием 1, где индекс 0 под dcc32 молча трогает соседнее поле записи, а FPC останавливает тот же цикл ошибкой проверки диапазона на этапе компиляции
При выключенной проверке границ dcc32 индекс 0 молча приземляется на соседнее поле записи, тогда как FPC отвергает тот же цикл на этапе компиляции
var
  I: Integer;
begin
  for I := 0 to 3 do                       // неверно: массив имеет диапазон [1..4]
    Data.AttachmentPoints[I] := Corner[I]; // dcc32 по умолчанию: компилируется, индекс 0
                                           // молча затрагивает соседнюю память
                                           // FPC: ошибка проверки диапазона на этапе компиляции
  for I := Low(TQuadrilateralPoint) to High(TQuadrilateralPoint) do
    Data.AttachmentPoints[I] := Corner[I - 1];  // корректно в обоих компиляторах
end;

Сборка Delphi — ложное срабатывание: с выключенной проверкой диапазонов (дефолт dcc32) индекс 0 попадает на то поле записи, что стоит перед массивом, и демо выглядит работающим. Тот же код под Lazarus даёт немедленную ошибку проверки диапазонов на этапе компиляции от FPC. Сторона аннотаций quad points разобрана в статье о quad-points аннотациях. Из этого следуют два урока. Первый: предпочитайте Low() и High() литеральным границам всегда, когда тип массива не 0-базный по построению. Второй: считайте сборку FPC, или как минимум одну сборку Delphi с {$R+}, обязательным гейтом первого запуска для любого нового демо или теста: дефолты dcc32 не расскажут вам об этом классе багов, а работающая программа — не доказательство её корректности

Проблема присвоения TBytes, компилируемая только в Delphi 13

Коротко: присвоение поля, объявленного как анонимный тип array of Byte, переменной строгого типа TBytes успешно собирается в Delphi 13 (версия компилятора 37.0), но вызывает ошибку сборки в Delphi 12 Athens и во всех более ранних версиях: E2010 Incompatible types: 'TArray<Byte>' and 'Dynamic array'. Эта проблема связана не столько с различиями Delphi и FPC, сколько с эволюцией самого компилятора Delphi: новая версия молча допускает конструкцию, которую все предыдущие версии считали некорректной

type
  TValidator = class
  private
    FBuffer: array of Byte;   // анонимный тип динамического массива
  end;

var
  OrigBytes: TBytes;
begin
  OrigBytes := FBuffer;          // только в Delphi 13; E2010 в Delphi 12
                                 // Athens и ранее
  OrigBytes := TBytes(FBuffer);  // компилируется везде; та же раскладка байтов,
                                 // безопасное жёсткое приведение
end;

В эту ловушку легко упасть, разрабатывая на Delphi 13, где неявное преобразование принимается молча: у пользователей, собирающих тот же исходник на Delphi 12 и старше, вылезает E2010. Структурный фикс — либо жёсткое приведение, показанное выше (оно безопасно, потому что анонимный array of Byte и TBytes имеют идентичную раскладку динамического массива), либо, лучше, изначальное объявление поля именованным типом вроде TBytes, чтобы преобразование вообще не возникало. Процессный фикс важнее: конструкция, компилирующаяся на вашей новейшей цепочке, не доказывает ничего про более старые компиляторы, которые реально запускают ваши пользователи, и этот класс проблем невидим, пока вы не соберёте против каждой поддерживаемой версии, потому что локальная сборка 37.0 не поймает снисходительность, появившуюся только в 13

Искажение байтов в AnsiString на китайской версии Windows

В одном предложении: конкатенация сырого байта от $80 и выше в AnsiString через + может молча заменить этот байт на ? ($3F) под Delphi, потому что выражение проходит неявный круг AnsiString to UnicodeString to AnsiString через системную кодовую страницу. Обычно это всплывает в тесте PDF/A, который строит имя с изолированным байтом $FE — никогда не легальным ведущим байтом UTF-8 — чтобы проверить, что валидатор помечает имена, не являющиеся валидным UTF-8 по ISO 19005-2, раздел 6.1.8

Диаграмма кругового пути AnsiString → UnicodeString, заменяющего сырой байт $FE вопросительным знаком на китайской машине Windows с CP936, рядом с безопасной правкой байта на месте в Delphi
Неявный обход UnicodeString «туда-обратно» заменяет несмаппируемый байт $FE на $3F под CP936, поэтому безопасный путь латает байт на месте
var
  BadName: AnsiString;
begin
  // В Delphi с многобайтовой системной кодовой страницей (наблюдалось на CP936),
  // конкатенация проходит через UnicodeString и $FE, что
  // не является допустимой последовательностью CP936 и возвращается как '?' ($3F)
  BadName := '/Bad' + AnsiChar($FE) + 'Name';

  // Безопасно: соберите с ASCII-заполнителем, затем исправьте байт на месте;
  // присваивание по индексу в устоявшемся AnsiString не проходит через округление
  BadName := '/Bad' + #1 + 'Name';
  BadName[5] := AnsiChar($FE);
end;

На китайской Windows с кодовой страницей 936 конкатенированная строка вообще не содержала $FE, так что валидатор корректно не сообщал ничего, а тест краснел по причине, не имеющей отношения к валидатору: получив PDF, реально содержащий байт $FE, он сообщал ожидаемый флаг. Порча происходила внутри тестового исполняемого файла Delphi при вычислении строкового выражения: Unicode-первая строковая модель Delphi прогоняет смешанные AnsiString-выражения через UnicodeString, а $FE — не валидный ведущий байт в CP936, поэтому круговая конвертация его заменяет. Будем честны насчёт границы: на однобайтной западной кодовой странице вроде CP1252 то же выражение обычно выживает — именно поэтому проблема прячется на большинстве машин разработчиков и всплывает только на восточноазиатских системах или локализованных CI-раннерах. Принятое правило: никогда не собирайте бинарные тестовые векторы с байтами от $80 и выше конкатенацией AnsiString; либо правьте байты на месте после того, как строка устаканилась, как выше, либо стройте вектор сразу в TBytes

Что должна включать проверка при кросс-компиляции

Четыре ловушки, один паттерн: каждый компилятор рассказывает вам о разном подмножестве ваших багов. Компилято-временной диапазонный анализ FPC ловит индекс вне границ, который dcc32 гоняет молча, а Unicode-строковая модель dcc32 выставляет зависимость от кодовой страницы, которую чисто байтовая сборка FPC никогда не триггерит. Практическое следствие: ни один зелёный конвейер сам по себе не достаточен. Кросс-компиляция — не просто галочка переносимости, это второй статический анализатор и вторая рантайм-модель, применённые к тому же исходнику, в том же духе, что и защитные проверки границ в статье о харденинге ABI и безопасности памяти

Постоянные правила, вытекающие из этих ловушек, коротки настолько, что их можно выучить. Прибивайте записи-результаты функций к локальной переменной, прежде чем читать поля. Итерируйте массивы с фиксированными границами через Low() и High() и гоняйте хотя бы одну сборку с проверкой диапазонов или сборку FPC, прежде чем доверять новому демо. Приводите анонимные поля динамических массивов явно или объявляйте их именованными типами, и собирайте полную матрицу компиляторов перед релизом. Держите сырые старшие байты подальше от конкатенации AnsiString. Ни одно из них не стоит измеримых усилий, когда становится привычкой, и каждое закрывает режим отказа, который однокомпиляторный воркфлоу структурно не видит

Эти правила родились из сопровождения PDFium Component, который поставляет один и тот же исходник на Object Pascal для Delphi, C++Builder и FPC/Lazarus