Question about library-level functions

[ytomino <aghia05@gmail.com>]

Hello.

What's the difference between a library-level(top-level?) function(A) and a function(B) in a library-level package?

with Something;
function A return access T; -- returns new allocated value

with Something;
package P is
   function B return access T; -- same as above
end P;

I had thought these are same.
But, returned value from A seems that's finalized inside A.
B is not.

Does the master of a library-level function happen to exist inside itself?




My test case is below:

---- %< ----

with Ada.Finalization;
package lifetime is
   type T is limited private;
   function Create return T;
private
   type T is limited new Ada.Finalization.Limited_Controlled with null record;
   overriding procedure Finalize (Object : in out T);
end lifetime;

with Ada.Text_IO;
with System.Address_Image;
package body lifetime is
   procedure Finalize (Object : in out T) is
   begin
      Ada.Text_IO.Put_Line ("Finalize (" & System.Address_Image (Object'Address) & ")");
   end Finalize;
   function Create return T is
   begin
      return Result : T := (Ada.Finalization.Limited_Controlled with null record) do
         Ada.Text_IO.Put_Line ("Initialize (" & System.Address_Image (Result'Address) & ")");
      end return;
   end Create;
end lifetime;

with lifetime;
function alloc return access lifetime.T;

function alloc return access lifetime.T is
begin
   return new lifetime.T'(lifetime.Create);
   -- lifetime.Finalize may be called here
end alloc;

with Ada.Text_IO;
with lifetime;
with alloc;
procedure main is
begin
   Ada.Text_IO.Put_Line ("before");
   declare
      type A is access all lifetime.T;
      P : A := A(alloc);
   begin
      -- P.all may be already finalized!!!
      Ada.Text_IO.Put_Line ("lifetime");
   end;
   Ada.Text_IO.Put_Line ("after");
end main;

---- >% ----

% gnatmake -gnat2012 main.adb && ./main
before
Initialize (0000000100100090)
Finalize (0000000100100090) <- !!!!
lifetime
after

When I tried to move 'alloc' to inside of any package, the calling lifetime.Finalize in 'alloc' would not be invoked. It's natural.