Требуется склонировать основное хранилище

https://osdn.net/projects/referencing/scm/hg/Referencing/

Поменять в gpr ключ -gnat12 на -gnat95 и добиться, чтоб тестовый пример собирался. Я делал на GNAT GPL 2017. Если собранный другой GNAT поддерживает -gnat95, сойдёт.

Я думал сам это сделать, чтоб начало положить, но не вывожу никак, рубит после китайского намертво, так и не довёл до конца.


Должен собираться и запускаться проект Referencing_Tester.gpr

Пока я пытался портировать, я столкнулся со следующим:

Limited_Reference — всё, что так называется, делается просто Reference. «subtype Limited_Reference is Reference;»

Limited_Reference принуждает не делать лишние копирования. В Delphi Result для больших объектов сразу по месту назначения выделяется, а в языке Ада, даже если написать return-do-end-return, компилятор временную переменную заводит, и только limited даёт возможность вкрутить ему мозги. В другом проекте, где контейнеры портируются, я делаю Ada 2012-подобый Ada 95-совместимый аналог, но в данном случае смысла в этой затее не увидел.

Limited_Reference в проекте используется в паре с Move. Move требует доступ на запись ко второму параметру. Все функции написаны так, что возвращают Limited_Reference. Возвращаемый Limited_Reference доступен только на чтение, но механизмы Ada 2012 приводят его к доступному на запись Reference, и Move работает. Чем-то это похоже на «&&» и семантику копирования в C++. Если же для Ada 95 объявлено «subtype Limited_Reference is Reference;», то Move такое не может пережевать. Надо заменять Move на Assign, где ругается. Ещё в Referencing.Tester.Main.adb есть строчки с объявлениями «… renames …», и компилятор в режиме Ada 95 на них жалуется. Там надо renames заменить на «… := …».

В версии Ada 95 нет записи методов через точку, поэтому X.Move (Y) и X.Assign (Y) надо переписывать на Move (X, Y) и Assign (X, Y), а поскольку Move меньше, где работает, то часть Move становится Assign.

Аспекты Pure и Preelaborate переделываются в pragma. Аналогично Inline_Always. overriding убирается. В одном месте процедуры стали dispatching, там Inline_Always надо заменить на Inline. Функция Release берёт параметр in out, что в Ada 95 не допускается. Надо переделать в процедуру с out параметром.

private with заменяется простым with.

Это всё, что я успел увидеть, пока занимался этим вопросом.

Перед фиксацией в https://osdn.net/projects/referencing/scm/hg/Referencing/ установить новую именованную ветку ada-95

В default там пусть остаётся Ada 2012 версия. Я, может, потом сведу ветки вместе, но в разных директориях, и когда видно будет, что насколько разъезжается.


Как получится на GNAT, можно переносить на AdaMagic.


Но, наверное, лучше файлы в хранилище Experiments скопировать и коммитить в Experiments, а не в Referencing.

Там система сборки, правда, нетривиальная. В Referencing для GNAT тестовый пример добавляет крючки на события копирования и освобождения, а в просто Referencing.gpr (как библиотека) этих крючков нет. Хоть как-нибудь для начала нужно запустить эту штуку.

Чтобы получать по почте уведомления о новых темах, на раздел форума нужно подписаться здесь

      ------------------------------
      -- Create_Limited_Reference --
      ------------------------------
      
      function Create_Limited_Reference
        return Limited_Reference_Base
      is
         Dummy : aliased Reference with Import, Address => Dummy_Structure'Address;
      begin
         return Result : aliased Limited_Reference_Base (Data => Dummy'Unchecked_Access) do
            declare
               Mutable_Result : Mutable_Limited_Reference
                 with Import,
                      Address => Limited_Reference_Conversions.To_Address
                                   (Result'Unchecked_Access);
            begin
               pragma Assert (Mutable_Result.Data = Dummy'Unchecked_Access);
               Mutable_Result.Data := Result.Wrapped'Unchecked_Access;
            end;
         end return;
      end Create_Limited_Reference;

В чём смысл последовательности операторов после слова "do"? Ведь они не меняют выходную переменную "Result".

Mutable_Result : Mutable_Limited_Reference перекрывает Result при помощи Import и Address

Так создаётся Ada 2012 ссылка, указывающая внутрь себя. Ada в норме такой механизм не предусматривает, но вроде бы всё хорошо должно быть. Такая ссылка запрещает копирование, которое так любит добавлять компилятор для копируемых результатов, не смотря ни на какие result-do-end-return. Такая ссылка, будучи возвращена, механизмами Ada 2012 приводится к просто ссылке, на которую указывает, но с доступом и на запись тоже. А, имея доступ на запись, можно уничтожающе переносить значение, и ещё на одно подёргивание счётчиком ссылок меньше.

При этом, если какой-то компилятор такие штуки не позволит, можно сделать медленную совместимую реализацию в динамической памяти. У Fast_Strings такая реализация возможна.

Применительно к Referencing я смысла в такой реализации не увидел, ведь давить на менеджер памяти заведомо хуже, чем лишний раз изменить счётчик ссылок. Поэтому



Я ещё столкнулся потом с тем, что где-то предполагается, что методы, унаследованные от Limited_, считаются перенесёнными вследствие того, что конструкция type … is new копирует все примитивные операции оригинального типа, а при замене type is new на subtype операции, конечно, не появляются.

Надо перенести операции, которые были примитивными для Limited_*, вверх из вложенного пакета Types, чтоб они стали примитивными для просто Reference. Create_And_Retain и т.п.

Я с этим разобрался.
Я портировал проект "Referencing.gpr". Сейчас портирую проект "Referencing_Tester.gpr".

Да, только портировав Tester, можно понять, что всё действительно работает

Я закончил портирование пакета "Referencing". В файле "Referencing.Tester.Main.adb" у меня синтаксис ОБЪЕКТ-ПАСКАЛЬ не проходит. Перед точкой можно использовать только квалификатор АДА-пакета, а не имя объекта. При портации я, наверное, изменил логику тестера. Проверьте, пожалуйста, правильность работы пакета.

Я пока не освоил работу с "TortoiseHg". Посылаю пока ссылку на упакованный пакет: Referencing.tar.xz. В файле build/build.txt инструкции по сборке пакета.

Что мне делать дальше?

PS: Я понял откуда появилось подобие синтаксиса ОБЪЕКТ-ПАСКАЛЬ: это результат добавления аспекта "with Implicit_Dereference => Data" к limited-типам. Но в АДА95 аспектов не существует и поэтому такой возможности не существует. В АДА95 нужно иметь доступ к полю "Data". В варианте пакета для АДА2012 это поле публично, так как является дескриптором типа. Но в АДА95 поля типа указателя не могут быть дескрипторами типа. И тут я допустил ошибку -- сделал это поле приватным не обеспечив публичного механизма доступа к этому полю. Какой мне вариант выбрать: сделать поле публичным или создать программный механизм доступа к приватному полю?

Такие конструкции заменяются на просто вызов функции. X.Assign (Y); → Assign (X, Y);

В Ada 2005+ оба варианта работают для любой примитивной операции tagged record, разве, может, для второго синтаксиса больше use надо подключить. В Ada 95 второй синтаксис безальтернативен, от чего у адаистов пригорало до самой Ada 2005, но виртуальные методы всё равно диспетчеризуются, как и положено в объектно-ориентированном языке программирования.



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



Таки освоить работу с TortoiseHg. Установить ветку ada95, написать сообщение ревизии, создать ревизию и отправить.



Нет, это для любого tagged типа так. Ada 2005+ контейнеры — все tagged, для любого контейнера в Ada 2005+ можно написать My_Vector.Append (Value) или My_Set.Include (Element).




Этот аспект даёт возможность Ada 2012-ссылке быть неявно приведённой к тому, на что она указывает своим Data.all. То, на что в Ada 2012+ версии Refererencing указывают Limited_ ссылки, является tagged record, поэтому к ним применим синтаксис Объект.Метод. Сами Limited_* типы объявлены не как tagged. Я насколько помню, я им никаких примитивных операций, берущих их как параметр, не объявлял, но если бы объявил, для них синтаксис Объект.Метод не работал, до тех пор, пока Limited_* тип не сделать tagged. Делать это было совершенно незачем, так он и остался без тега.

Как я уже писал, вся эта затея с Limited_* уменьшает количество копирований в Ada 2012. И без этого можно обойтись. Обойтись — значит, все функции вроде Tester.Plus возвращают обычную копируемую сильную ссылку, без Limited_*. В Ada 95 версии, наверное, лучше не subtype сделать, а совсем выпилить, чтоб не сбивала с толку.



Могут. Но такие дискриминанты превращают тип в limited, а с limited в Ada 95 работу ещё не сделали удобно. Кроме указательных дескрипторов (синтаксис Data : access Name_Of_Type) ещё бывают дискриминанты именованных указательных типов (синтаксис Data : Stream_Access := null). Я рассматриваю их как возможность в Ada 95 делать трюки, похожие на Ada 2012+, но до конца не проверял. Если функция выделяет в динамической памяти нечто и возвращает копируемое (не limited) значение с именованным указательным дискриминантом, а в declare-begin-end используется синтаксис Some_Value : Some_Type renames Some_Function (Some_Parameter).Data.all, будет ли результат функции жить до конца end, как это сделано для указательных дискриминантов.




Заменить пока все ссылки Limited_* их копируемыми аналогами.

Закончил портирование и влил результат на сервер в ветвь "ADA95".
Непонятный стековый фрейм:

...
   private
      type Limited_Reference_Base
        (Data : not null access Reference) is
      limited record
         Wrapped : aliased Reference;
      end record;
   end Operations;
...

преобразовал в эквивалентный:

...
   private
      type AUX_Reference_Base
        (Data : Reference_Ptr := null) is
      record
         Wrapped : aliased Reference;
      end record;
   end Operations;
...

Вроде всё работает. Но переносить в AdaMagic пока рановато. Очень много излишеств.
АДА это не СИ++, и делать обёртки для указателей нет абсолютно никакой необходимости! Параметры в процедуры, на самом деле, всегда передаются по ссылке, за исключение тех параметров, которые вмещаются в машинное слово. Так что никаких лишних копирований не происходит.
Давайте начнём с конца, применим, так сказать, восходящий метод разработки.
Придумайте простенькую грамматику, напишите небольшой исходный текст (мне это сделать трудно, я уже старый и у меня для этого совершенно не хватает воображения), а я создам парсер для этой грамматики и протестирую его.
Проблемы с ЮНИКОДОМ можно решить с помощью пакета "XmlAda". За основу разрабатываемого РИДЕРА можно взять РИДЕР из этого пакета, а не из системной библиотеки. "XmlAda" -- пакет для АДА95 и вот его можно переносить на AdaMagic. С ЮНИКОД-литералами проблема остаётся, но и тут можно что-то придумать. К стати, GNAT2012 -- единственный в GCC компилятор, который правильно строит и интерпретирует ЮНИКОД-литералы и идентификаторы.
Что вы на это скажете?

Наблюдается прогресс.

Что я вижу.

https://osdn.net/projects/referencing/scm/h…4a8d949c8b39a68

В сообщении фиксации указан id #32737, а у текущей задачи номер 32744.

В двух других сообщениях вообще нет номера. Была же настройка для этого в TortoiseHg, чтоб требовать проставление.

В шапку изменённых файлов нужно добавлять копирайт с именем и годом ниже строкой под существующими.



Не адский стиль.




Теперь отвечаю.



Понятность резко увеличивается, если версию тестера для Ada 2012 запустить и посмотреть, что в консоли. Пока не запустить, может быть непонятно, да.



Можно увидеть разницу, какая чехарда с двумя избыточными Retain при := происходит, и что при Assign, и Move. Но Assign и Move для этого на вход должны были получить объект, созданный сразу на месте.

В Ada 95 так нормально сделать не получится. Хотя, впрочем, если все функции на процедуры переделать, то получиться, но таким методам и Limited_ не будет нужен, чтоб они в нужное место сразу писали. В очередной раз жертвовать синтаксисом, как будто было мало без этого отказа от синтаксиса Объект.Метод и строковых литералов, не хочется, так что будут функции и будет чехарда при возврате результатов.



Автоматический подсчёт ссылок без этого не сделать. Было бы здорово, чтоб access мог тоже быть Controlled. Но такого нет. И экономический фундамент Ады не способствует, чтоб появился, а экономический фундамент Делфей не способствует изучению лучших практик Ады.

Так и разрываемся. Но разрываться я выбрал так, чтоб со стороны Ады тянуться к Делфям, и в языке Ада для этого достаточно возможностей, а обратное до сих пор неверно.



Я попрошу вообще выбросить его.

Такие трюки понадобятся, но позже, для контейнеров.



Я работал с IXMLDocument в Delphi, и с DOM в XmlAda. Ада просто копец. И почему? Потому что для DOM нет счётчика ссылок.

Я работал с TJSONValue в Delphi и с GNATCOLL.JSON. На этот раз копец был в Делфи. И почему? А всё потому же.

В AWS многое сделано неплохо, но вот как надо отдать поток вместо готового текста, так начинается боль. Вернём Response.Stream, а дальше на полпути, допустим, украшатель стоит. Перехватывает 404, заменяет чем-то своим. Вот если в самый вниз Response.Stream провалился, понятно, а если перехвачен? Там система управления памятью какая-то, я с неё не могу. Какие-то пометки, то ли захвачен Stream в Response, то ли нет. Что вообще? Как же это бесит. И от стандарта ARC встроенного не приходится ожидать, и адаисты, которым не посчастливилось не иметь опыта работы с ARC хотя бы в Delphi, пишут код, который приводит в расстройство. Не такое расстройство, как на других языках, но всё же от игры на таком инструменте, как Ада, ожидается большее.

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

А как узнать текущий номер задачи?
И ещё, как делать подтверждение только для локального хранилища? Что-то в руководствах я этого не нашёл.


В GNATCOM всё это сделано средсвами АДЫ без обёрток для указателей!
В GNATCOM все интерфейсные типы наследуются от типа "Interface_Type", реализация которого и обеспечивает автоматический подсчёт ссылок. Вот его определение:

   type Interface_Type is new Ada.Finalization.Controlled with private;
...
private

   type Interface_Type is new Ada.Finalization.Controlled with
      record
         Interface_Address : aliased System.Address := System.Null_Address;
         IID               : aliased GNATCOM.Types.GUID :=
           GNATCOM.Types.IID_IUnknown;
      end record;

Автоматический подсчёт ссылок обеспечивается реализацией следующих процедур:

   ------------
   -- Adjust --
   ------------

   procedure Adjust (This : in out Interface_Type) is
   begin
      AddRef (This);
   end Adjust;

   --------------
   -- Finalize --
   --------------

   procedure Finalize (This : in out Interface_Type) is
   begin
      Free (This);
   end Finalize;

   ----------
   -- Free --
   ----------

   procedure Free (This : in out Interface_Type) is
   begin
      Release (This);
      This.Interface_Address := System.Null_Address;
   end Free;

Как говорил Коперник: "Вселенная устроена Просто. Божественно Просто!".
В GNATCOM там где нужно передать интерфейсный объект в качестве входного параметра COM-серверу, передаётся голый указатель, чего требует соглашение "stdcall" использующееся в COM. Там же где нужно как-то изменить значение интерфейсного типа, строится дополнительная процедура, куда параметры интерфейсного типа передаются с квалификаторами "in out". В COM на уровне IDL, в отличии от СИ++, квалификаторы "in" и "out" -- значимые, что нужно учитывать при реализации кода интерфейсных объектов. Так что получается, что в АДЕ этот аспект реализовать проще чем в СИ++!

Давайте определим некий базовый тип, который определит общую базовою функциональность для наших задач. Автоматический подсчёт ссылок в рамках этого определения организовать очень просто, надеюсь я вас в этом убедил. Так что данную тему можно закрыть.

Если не хотите начать восходящую разработку с самого конца, потому что, я думаю, не совсем определились с конечной целью ваших разработок, то давайте начнём восходящую разработку с модификации ЧТЕЦА из пакета "XmlAda", который должен иметь функциональность автоматического подсчёта ссылок и являться контейнером закладок.
Вы согласны со мной?

В адресе написано примерно следующее: forum.pascal.net.ru/index.php?showtopic=32744




Не понял.



Почему без? Указатель в поле Interface_Address. А Interface_Type — его обёртка. Всё так.



Мы делаем не COM, мы делаем сейчас на Аде фундамент. Про stdcall в COM можно не думать.



Referenced и реализует такую функциональность базового типа. Потом, когда потребуются слабые ссылки, их можно будет в Referenced добавить.



Не хочу без повода брать XmlAda. Он LGPL. Xml из него бесполезен, разве что если заморочиться и переписать. Кодировки, отличные от UTF-8, в быту могли бы пригодиться, но по плану их нет. Только UTF-8

Вы мне показывали как делать "commit" для локального хранилища, а потом синхронизировать локальное хранилище с сервером. У меня же синхронизация с сервером происходит автоматически и ошибки, допущенные при формировании запроса "commit", безвозвратно уходят на сервер, и исправить больше ничего нельзя.
Как мне с этим быть?


Дело не в COM, а в том что в АДСКОМ программировании вообще не нужно обращаться к указателям, за исключением того случая, когда нужно создать объект с помощью оператора "new", но и потом нужно обращаться не к указателю, а к разыменованному его содержимому как к объекту типа. В ваших кодах оператора "new" вообще нигде нет. В GNATCOM указатели функционально необходимы, но проблем с подсчётом ссылок нет.


Так и сделаем тип "Referenced" базовым, а пакет "Referencing" похерим. Он не нужен. Тем более, что в этом случае можно обойтись без лишнего "generic". Только дадим ему другое название, потому что он должен будет реализовывать не только функциональность подсчёта ссылок, но и что нибудь ещё.


Я считаю пакет "XmlAda" очень полезным для наших задач.
В нём, помимо проектов "XmlAda_Dom", "XmlAda_Sax", "XmlAda_Schema", "XmlAda_Unicode", содержится очень полезный для нашей ближайшей задачи проект "XmlAda_Input". ЧТЕЦ в нём умеет правильно читать UTF-8 файлы. Стандартный пакет "Ada.Wide_Wide_Text_IO" не умеет правильно это делать, хотя умеет правильно писать в UTF-8 файл. Так что использовать в качестве основы ЧТЕЦ из этого пакета не представляется возможным. Проект "XmlAda_Input" зависит только от проекта "XmlAda_Unicode" и является АДА95-совместимым. Так что эти два пакета можно малой ценой собрать в AdaMagic.

Теперь о лицензиях.
В текущем проекте я заменил системный пакет "System.Atomic_Counters" на пакет "Atomic_Counters". Но я его не изобретал, не проектировал, а слегка подкорректировал. Сделал совместимым с АДА95 (в АДА95 пакета "System.Atomic_Counters" нет). Как заполнять шапку реализации в таких случаях?

И если я не могу воспользоваться богатством свободного программного обеспечения мирового сообщества, то почему я должен оставаться в рамках лицензии "Apache License, Version 2.0"?
Проект "Apache" насквозь провонял коммерцией. А коммерсанты всегда были и являются самыми отъявленными халявщиками. Им уж очень и очень, и очень не хочется ни за что платить.

Вы когда нибудь сталкивались с чудовищами, которых вы называете "Патентными Троллями"? И что в них такого страшного? И как лицензия "Apache License, Version 2.0" гарантирует защиту от них?


Я уже два раза задавал подобный вопрос и не получил ответа.
Так давайте же займемся чем-то конкретным, а не будем размусоливать и учить друг друга уму-разуму. Проблемы будем решать по мере их возникновения.

В последнем предложении я ошибся. операторы "new" есть и без них не обойтись.

В последней редакции удалил все дополнительные стековые фреймы. Результат на сервере.

Ничего не поделать. Оформление касается последующих правок. Я смотрю, всё нормально дальше пошло.



new было здесь:

   -----------------------------
   -- Sample_Reference.Create --
   -----------------------------
 
   function Create
     (Value : Integer)
     return Sample_Limited_Reference is
   begin
      return Result : Sample_Limited_Reference := Create_Limited_Reference do
         declare
            New_Object : not null Types.Sample_Access := new Types.Sample_Referenced;
         begin
            Operations.Set (Result, New_Object);
            Types.Create (New_Object, Value);
         end;
      end return;
end Create;

Чтобы в АДСКОМ программировании к указателям обращаться было не нужно, их для этого кто-то должен был завернуть. Например, во всех (кроме библиотеки SPARK 2012) контейнерах указатели внутри есть. Мы тоже этим занимаемся, заворачиваем, чтоб наружу смотрело только красивое.



В смысле, не нужен. А куда Referenced денется?



Это без чего можно обойтись?



Это, наверное, касается реализации, а не заложенных в стандарт возможностей. В Ada 95 нет Wide_Wide_Text_IO, а Wide_Text_IO мне не нужен. *_Text_IO, когда файл открывают, имя файла требуют так называемыми восьмибитными символами, отчего у меня глаза кровью просто наливаются. Со Stream_IO, к сожалению, та же история, но будет использоваться он. По плану сделать кривую минимальную реализацию 4байтового юникодного API с открытием и чтением файлов, а потом постепенно, обращаясь к системным API, добиваться поддержки Юникода на ожидаемом уровне.




Это, по большому счёту, привязки к интринсикам GCC. Программные интерфейсы не лицензируются. Алгоритмов там никаких выдающихся не наблюдается. Можно ставить всё такую же шапку.



В других ситуациях будет можно, но сейчас фундамент требуется определённым образом устроенный и общедоступный.



Пусть не платят. Так и задумано.



Генри Форд сталкивался, о чём писал в своих книгах. Лицензия Апаче гарантирует защиту не нам, а от нас, имея в виду под нами и других возможных присоединившихся авторов кода.




Я не согласен связываться с XmlAda.

Про конечные цели здесь. Могу ещё добавить.


Что-то конкретное сейчас подразумевает выпилить Limited_ из Ada 95 версии или сообщить мне, что не получается. Если совсем не получается, могу выдать следующее задание.

К четвергу или пятнице порешаю, попробую сам доделать.

Добавлено через 3 мин.


Хорошо, пишу тогда следующее задание

А как расшифровать шаблон "\#(\d+)"? С номером понятно, а что в скобках? Это дата или что-то ещё? Приведите, пожалуйста, пример строки, удовлетворяющей данному регулярному выражению.

\d = любая цифра.
+ = жадно 1 или более раз
скобки ограничивают действие плюса и одновременно захватывают цифры в группу {1}. В {0} вся сопоставленная строка, в {n} — сопоставление группы, начатой n-й открывающей скобкой


#3
#8
#478587
#2393684
#00000
#05852
#200
#0