]]> ]]>

Free Pascal 2.2.0

Версия реализации Free Pascal языка программирования Pascal

На момент написания статьи версия 2.2.0 — последняя стабильная.

Основные изменения относительно версии FPC 2.0.4:

Платформы:

  • Новая платформа: Win64. FPC — первый open source-компилятор для операционной системы Windows 64-бит
  • Новая архитектура процессора: 64-bit PowerPC
  • Подержка PowerPC/64 на Linux
  • Теперь поддерживается Mac OS X на Intel (i386)
  • Новая платформа: Windows CE (Windows Mobile)
  • Новая платформа: Nintendo Game Boy Advance
  • Новая платформа: Nintendo DS
  • Нативная поддержка для платформы ARM
  • Обновлена поддержка платформы GO32V2 DOS

Компилятор:

  • Внутренний компоновщик для win32, win64 и wince
  • Generic (экспериментально)
  • Поддержка нескольких файлов ресурсов
  • pointer[low..high]-синтаксис для передачи указателей в стиле C в процедуры
  • Делегирование интерфейсов
  • Реализация safecall
  • Widestring под Windows COM/OLE-совместимы
  • Оптимизирована скорость выполнения программ
  • Полная поддержка компилятором путей более 255 символов длиной
  • Отладка: поддержка Dwarf
  • Уменьшено использование памяти при компиляции
  • Множество мелких исправлений, в том числе по совместимости

RTL:

  • Куча использует меньше памяти
  • Улучшенная поддержка variant
  • Улучшенная поддержка currency
  • Обработка исключений может быть использована без модуля SysUtils
  • Множество мелких исправлений, в том числе по совместимости

FCL:

  • Улучшенная поддержка баз данных
  • Удалены устаревшие модули sqlitedataset, interbase, fpodbc, ddg, mysqldb3 и mysqldb4
  • Множество мелких исправлений, в том числе по совместимости

Пакеты:

  • Добавлен новый менеджер пакетов fppkg
  • Улучшенная поддержка баз данных
  • Добавлен совместимый с Delphi модуль RichEdit
  • Множество мелких исправлений, в том числе по совместимости

Free Vision:

  • Теперь использует resourcestring

Интегрированная среда разработки:

  • Evaluate window
  • Улучшенный рендеринг HTML
  • Улучшенная поддержка xterm
  • Небольшие исправления ошибок

Другое:

  • Улучшенная документация
  • Улучшенная поддержка кросс-компиляции

Изменения, которые могут влиять на работоспособность кода программ:

Для всех платформ:

  • Изменения типа string в режиме Delphi. В версии 2.2.0 по умолчанию используется директива компилятора {$h+} вместо {$h-}. Это означает, что string рассматривается теперь как ansistring по умолчанию. Данное изменение может привести к неработоспособности кода, ориентированного на работу с shortstring. Решение данной проблемы возможно либо путем адаптации кода для работы с ansistring либо принудительного указания директивы компилятора {$h-}.
  • Изменения работы с константами-числами с плавающей точкой. В прежних реализациях FPC использовалась максимальная точность, допустимая на платформе, теперь же используются минимальная точность, которая не вызывает потерю данных. В результате этого нововведения некоторые конструкции могут давать точность меньшую, чем в прошлом. Если требуется большая точность вычисления, то рекомендуется использовать типы с большей точностью вычисления, например, extended.
  • Изменение типа System.Exitcode для совместимости с Delphi и ОС, поддерживающими 4-х байтовый код завершения. Во всех реализациях вплоть до 2.0.4 переменная System.Exitcode была объявлена как word, теперь она объявлена как longint. В результате этого изменения не все ассемблерные вставки могут работать корректно с Exitcode.
  • Удален RTLEventStartWait. Прежде необходимо было вызывать RTLEventStartWait перед запросом RTLEventWaitFor из-за особенностей реализации в UNIX-системах. В результате этого изменения код, использующий вызов RTLEventStartWait, будет неработоспособен, необходимо удалить вызовы RTLEventStartWait, т.к. в них больше нет необходимости.
  • Изменение работы операции in. В прежних реализациях левый операнд преобразовывался в тип byte, подобно Turbo Pascal. Теперь же размер операнда сохраняется, но до конца еще не реализована поддержка чисел больше 256.
  • Прежде было допустимо приведение неявным образом к 32-х разрядному целочисленному типу некоторых строк. Теперь конструкции типа dword1:='ab'; будут запрещены, но строки длинной в 4 символа могут быть неявно преобразованы к 32-х разрядному целочисленному типу.
  • Режим GPC отключен. {$mode gpc} и -mgpc теперь не работают.
  • TFPHashtable переименован в TFPDataHashTable из-за введения нового класса TFPCustomHashTable.

Изменения для платформы UNIX:

  • Постоянство RTLEvent. Многократные вызовы RTLEventSetEvent теперь не теряются и скапливаются в очереди. Сделано для совместимости с поведением под Windows.

Изменения для платформы PowerPC:

  • Изменение вычислений с плавающей точкой. Теперь вычисления будут выполняться не с двойной точностью как было ранее по умолчанию. Сделано для увеличения быстродействия.

Изменения для 64 разрядных платформ:

  • Теперь Variant-массивы используют 32-битные, а не 64-битные индексы. Введено для совместимости со стандартными подпрограммами Windows и программами, написанными на других языках.

Ссылки:

Примеры:

Факториал - Pascal (2):

Используется рекурсивное определение факториала.

Этот пример работает во всех перечисленных компиляторах, но с несколько разным результатом. В Turbo Pascal, Free Pascal и PascalABC.NET возникает арифметическое переполнение при вычислении факториалов 13-16, но Free Pascal сообщает об ошибке:

13! = Runtime error 215 at $004013C7
$004013C7
$00401449
$004063E0

в то время как Turbo Pascal и PascalABC.NET не обнаруживают ошибку и просто выводят неправильные значения:

13! = 1932053504
14! = 1278945280
15! = 2004310016
16! = 2004189184

Следует отметить, что в версиях Turbo Pascal 3.0 и младше этот пример не работает вообще из-за отсутствия типа данных longint.

В GNU Pascal пример работает без переполнения. 

program factorial;

function fact(n: integer): longint;
begin
    if (n = 0) then
        fact := 1
    else
        fact := n * fact(n - 1);
end;

var
    n: integer;

begin
    for n := 0 to 16 do
        writeln(n, '! = ', fact(n));
end.

Числа Фибоначчи - Pascal (28):

Этот пример использует рекурсивное определение чисел Фибоначчи. 

program fibonacci;

function fib(n:integer): integer;
begin
    if (n <= 2) then
        fib := 1
    else
        fib := fib(n-1) + fib(n-2);
end;

var
    i:integer;

begin
    for i := 1 to 16 do
        write(fib(i), ', ');
    writeln('...');
end.

Hello, World! - Pascal (47):

program helloworld;

begin
    writeln('Hello, World!');
end.

Факториал - Pascal (93):

Этот пример работает точно так же, как основной рекурсивный пример для Pascal, но использует тип real для хранения значений факториала. Команда writeln(f:-1:0) выводит дробное число f с 0 цифр после десятичной запятой и выравнивает его по левому краю. 

program factorial;

function fact(n: integer): real;
begin
    if (n = 0) then
        fact := 1
    else
        fact := n * fact(n - 1);
end;

var
    n: integer;

begin
    for n := 0 to 16 do
        writeln(n, '! = ', fact(n):-1:0);
end.

Квадратное уравнение - Pascal (143):

В Pascal есть встроенный комплексный тип данных complex, но команда writeln не работает с ним напрямую (только через функции Re и Im), поэтому существенного удобства от его использования нет. Вычисления проводятся в типе real. Библиотечная функция halt, введенная в Extended Pascal, позволяет выйти из текущего блока (в более поздних версиях заменена на exit). 

program Quadratic;

var
   A,B,C,D: integer;

begin
   write('A = ');
   readln(A);
   if (A=0) then
   begin
      writeln('Not a quadratic equation.');
      halt;
   end;
   write('B = ');
   readln(B);
   write('C = ');
   readln(C);
   D := B*B-4*A*C;
   if (D=0) then
   begin
      writeln('x = ',-B/2.0/A);
      halt;
   end;
   if (D>0) then
   begin
      writeln('x1 = ',(-B+Sqrt(D))/2.0/A);
      writeln('x2 = ',(-B-Sqrt(D))/2.0/A);
   end
   else
   begin
      writeln('x1 = (',-B/2.0/A,',',Sqrt(-D)/2.0/A,')');
      writeln('x2 = (',-B/2.0/A,',',-Sqrt(-D)/2.0/A,')');
   end;
end.

CamelCase - Pascal (275):

Программа обрабатывает строку посимвольно. Для определения того, является ли символ буквой, и если является, то в каком он регистре, используются ASCII-коды символов. Функция ord возвращает ASCII-код данного символа, а chr — символ по его коду. Размерность строк не задана и по умолчанию принимается равной 255.

Отметим, что в Turbo Pascal программа работает только начиная с версии 4.0; в более ранних версиях не было типа данных char. 

program Camelcase;

var
    text, cc: string;
    c: char;
    i: integer;
    lastSpace: boolean;

begin
    readln(text);
    lastSpace := true;
    cc := '';
    for i := 1 to Length(text) do
    begin
        c := text[i];
        if ((c >= #65) and (c <= #90)) or ((c >= #97) and (c <= #122)) then
        begin
            if (lastSpace) then
            begin
                if ((c >= #97) and (c <= #122)) then
                    c := chr(ord(c) - 32);
            end
            else
                if ((c >= #65) and (c <= #90)) then
                    c := chr(ord(c) + 32);
            cc := cc + c;
            lastSpace := false;
        end
        else
            lastSpace := true;
    end;
    writeln(cc);
end.

CamelCase - Pascal (276):

Пример использует такую же логику, как и предыдущий, но для проверки того, является ли символ буквой, используются множества символов lower и upper. Это делает код более читабельным.

Отметим, что в Turbo Pascal программа работает, начиная с версии Turbo Pascal 4.0, в которой впервые появляется тип данных char. 

program Camelcase;

var
    text, cc: string[100];
    c: char;
    i: integer;
    lastSpace: boolean;
    upper, lower: set of char;

begin
    upper := ['A'..'Z'];
    lower := ['a'..'z'];
    readln(text);
    lastSpace := true;
    cc := '';
    for i := 1 to Length(text) do
    begin
        c := text[i];
        if (c in lower) or (c in upper) then
        begin
            if (lastSpace) then { convert to uppercase }
            begin
                if (c in lower) then
                    c := chr(ord(c) - 32);
            end
            else { convert to lowercase }
                if (c in upper) then
                    c := chr(ord(c) + 32);
            cc := cc + c;
            lastSpace := false;
        end
        else
            lastSpace := true;
    end;
    writeln(cc);
end.

Комментарии

]]>

blog comments powered by Disqus

]]>

Работа программистам