GNAT 2011, (с поддержкой многих фич стандарта А2012) Опции

[IUnknown]

Итак, 14 июня вышла наконец долгожданная версия GNAT GPL 2011.

Много улучшений, новая версия самой IDE (теперь это версия 5.0.1, вместо 4.3.1 из 2009-ой версии, и 4.4.1 из 2010), мне нравится больше, чем прежняя, одна возможность фильтрации результатов компиляции чего стОит (хотя это вроде было и в 2010, но мне сравнивать не с чем, я сразу перешел 2009 -> 2011, поэтому все нововведения будут относительно предпоследней версии).

Что говорит официальная страничка (комментарии - мои):

1. Улучшенная поддержка А2012 (да, это - главная причина, по которой я обновился. Теперь есть возможность использовать все те фичи, которые на настоящий момент утверждены для нового стандарта, а не просто наблюдать сообщение, что это будет доступно в 2012 году, как было в прежней версии GNAT. Это и "in out" параметры для функций, и условные выражения, и Case-выражения, работают Quantified expressions, дискриминанты для лимитированных тэговых типов, Pre/Post-условия, и многое другое из того, что уже внесено в окончательную редакцию стандарта)
2. Улучшенные версии (GPS 5.0 - расширенная поддержка С/С++, более мощный редактор, повышенное юзабилити, GtkAda - новые виджеты, интерфейс к граф. библиотеке Cairo). (От себя добавлю, что в редакторе наконец-то сделали выпадающий список Pragma, и список атрибутов типа:
   
   )
3. Более гибкий и эффективный менеджер проектов
4. Поддержка выгрузки плагинов
5. Улучшенная поддержка конструкций на .NET-платформе
6. Более детальные сообщения об исключениях (при использовании ключа -gnateE)
7. полная поддержка платформы Lego Mindstorms NXT, включая аудио и I2C-сенсоры (об этом есть ролик на youtube, англ.: вот он )

Как видно, много народу хочет попробовать новую среду/новый компилятор - я скачивал пакет размером 140Мб почти 12 часов, скорость иногда падала до 2-3Кб/сек. Но сейчас с этим вроде справились.

Сообщение отредактировано: IUnknown - 17.06.2011 14:40

[IUnknown]

К тому же предполагается, что порядок действий и значение констант должны как бы вводиться пользователем, то есть порядок инициализации пакетов не должен быть мёртво вшит в код. Например, для моего варианта хоть порядок создания функций и задан руками, но я могу спокойно запихать создание функций в условный оператор, сделать массив функций итд.

В таком случае - только вот это:

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Real_Time; use Ada.Real_Time;

procedure Test is

   type Arity is (Unary_Function, Binary_Function);

   type Rec;
   type Rec_Ptr is access all Rec;

   type Rec (R : Arity) is limited record
      Self : Rec_Ptr := Rec'Unchecked_Access;
      f : access function (This : Rec_Ptr) return Integer;

      case R is
         when Unary_Function =>
            Value : Integer;
         when Binary_Function =>
            Left : Rec_Ptr;
            Right : Rec_Ptr;
         when others =>
            null;
      end case;

   end record;

   --  Это будет та самая Ret_Const
   function fun (This : Rec_Ptr) return Integer is
   begin
      return This.Value;
   end fun;

   --  А это - любая из "+", "-", "*"
   generic
      with function f (L, R : Integer) return Integer;
   function bfun (This : Rec_Ptr) return Integer;

   function bfun (This : Rec_Ptr) return Integer is
      L : Rec_Ptr := This.Left;
      R : Rec_Ptr := This.Right;
   begin
      --  Это выполняется дольше
      --  return f(This.Left.f(This.Left.Self), This.Right.f(This.Right.Self));

      --  Это - быстрее.
      return f(L.f(L.Self), R.f(R.Self));
   end bfun;

   function Create_Unary(Value : Integer) return Rec_Ptr is
   begin
      return Result : Rec_Ptr := new Rec'(R => Unary_Function, Self => <>,
                                          f => fun'Access, Value => Value) do
         null;
      end return;
   end Create_Unary;

   type BinFunc is access function (This : Rec_Ptr) return Integer;
   function Create_Binary(bf : BinFunc;
                          L, R : Rec_Ptr) return Rec_Ptr is
   begin
      return Result : Rec_Ptr := new Rec'(R => Binary_Function, Self => <>,
                                          f => bf, Left => L, Right => R) do
         null;
      end return;
   end Create_Binary;

   function add_bfun is new bfun(f => "+");
   function sub_bfun is new bfun(f => "-");
   function mul_bfun is new bfun(f => "*");

   Fs : array(1 .. 17) of Rec_Ptr;
   IntValue : Integer;
begin

   Fs(1) := Create_Unary( 7);
   Fs(2) := Create_Unary( 8);
   Fs(3) := Create_Unary( 5);
   Fs(4) := Create_Unary( 6);
   Fs(5) := Create_Unary(48);
   Fs(6) := Create_Unary( 2);
   Fs(7) := Create_Unary( 3);
   Fs(8) := Create_Unary( 6);
   Fs(9) := Create_Unary( 9);
   Fs(10) := Create_Binary(mul_bfun'Access, Fs( 3), Fs( 4));
   Fs(11) := Create_Binary(mul_bfun'Access, Fs( 5), Fs( 6));
   Fs(12) := Create_Binary(add_bfun'Access, Fs( 8), Fs( 9));
   Fs(13) := Create_Binary(mul_bfun'Access, Fs( 7), Fs(12));
   Fs(14) := Create_Binary(add_bfun'Access, Fs( 1), Fs( 2));
   Fs(15) := Create_Binary(sub_bfun'Access, Fs(14), Fs(10));
   Fs(16) := Create_Binary(add_bfun'Access, Fs(15), Fs(11));
   Fs(17) := Create_Binary(sub_bfun'Access, Fs(16), Fs(13));

   IntValue := Fs(17).f(Fs(17).Self);
   Ada.Text_IO.Put_Line (Integer'Image (IntValue));
end Test;

Очень похоже на дерево, по скорости тоже почти одинаково, хотя все-таки этот способ чуть-чуть быстрее.