Accessibility Levels and Library-Level Units

Accessibility Levels and Library-Level Units

[Eryndlia Mavourneen]

I have a package that defines a single procedure access type:

   1. package Accessibility_Level_Def is
   2.   pragma Pure;
   3.   type Proc_Type is access procedure (An_Str : String);
   4. end Accessibility_Level_Def;

I have a main program which references it (and another package):

    1. with Ada.Text_IO;                        use Ada.Text_IO;
    2. with Accessibility_Level_Def;            use Accessibility_Level_Def;
    3. with Accessibility_Level_Implementation; use Accessibility_Level_Implementation;
    4. procedure Accessibility_Level_Test is
    5.    procedure Test (Text : String);
    6.    procedure Test (Text : String) is
    7.    begin
    8.       Put_Line ("in Test");
    9.    end Test;
   10. 
   11.    The_Proc : Proc_Type;
   12. begin
   13.    The_Proc := Test'Access;
   14.    Sub (Proc => The_Proc);
   15. end Accessibility_Level_Test;

Gnat 2012 (on Ubuntu) gives the error on line 13:

   "Subprogram must not be deeper than access type."

I thought I understood accessibility levels, at least, I understood the examples I have found.  Yet, this example appears to not have the same issues:

1) All the units -- packages and procedure -- are at library level.
2) The procedure is statically defined and is not going to be 
   deallocated until the program exits.

This is very frustrating and would seem to preclude the definition of a procedural access type in a separate definitions package.  The Implementation package (defining procedure Sub but not shown) compiles nicely, btw.

Is this a problem with Gnat?  If not, how can I do what I want to do?  The attribute Unchecked_Access is not available for subprogram access types.

-- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[Eryndlia Mavourneen]

Actually, I realize that the nested procedure whose 'Access is taken is not at library level, but it still is frustrating that this obviously(?) safe code is not acceptable to the compiler.

-- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[mockturtle]

I am not a language lawyer, so maybe someone will be able to confirm/contradict me.  

I think that the problem is that Test is "local to" (defined inside) Accessibility_Level_Test.  The problem is that you could have a "perverted" procedure Sub like this


package body Bad is

  Old_Access : Proc_Type;

  procedure Sub(X : Proc_Type) is
  begin
    Old_Access := X;
  end Sub;

  procedure Boom is
  begin
    Old_Access("Boom");
  end Boom;
end Bad;

Now, if your code was legal you could call 

  Accessibility_Level_Test;  
  Bad.Boom; 

and the latter would use the access to (non-existing) Test saved by Sub, causing... a boom.

From your post I understand that   Accessibility_Level_Test;  is the "main" program, but I am afraid that this does not count, but maybe a LL would be able to explain this better.

Hope this help

Riccardo

On Tuesday, September 24, 2013 8:36:43 PM UTC+2, Eryndlia Mavourneen wrote:
> I have a package that defines a single procedure access type:
> 
> 
> 
>    1. package Accessibility_Level_Def is
> 
>    2.   pragma Pure;
> 
>    3.   type Proc_Type is access procedure (An_Str : String);
> 
>    4. end Accessibility_Level_Def;
> 
> 
> 
> I have a main program which references it (and another package):
> 
> 
> 
>     1. with Ada.Text_IO;                        use Ada.Text_IO;
> 
>     2. with Accessibility_Level_Def;            use Accessibility_Level_Def;
> 
>     3. with Accessibility_Level_Implementation; use Accessibility_Level_Implementation;
> 
>     4. procedure Accessibility_Level_Test is
> 
>     5.    procedure Test (Text : String);
> 
>     6.    procedure Test (Text : String) is
> 
>     7.    begin
> 
>     8.       Put_Line ("in Test");
> 
>     9.    end Test;
> 
>    10. 
> 
>    11.    The_Proc : Proc_Type;
> 
>    12. begin
> 
>    13.    The_Proc := Test'Access;
> 
>    14.    Sub (Proc => The_Proc);
> 
>    15. end Accessibility_Level_Test;
> 
> 
> 
> Gnat 2012 (on Ubuntu) gives the error on line 13:
> 
> 
> 
>    "Subprogram must not be deeper than access type."
> 
> 
> 
> I thought I understood accessibility levels, at least, I understood the examples I have found.  Yet, this example appears to not have the same issues:
> 
> 
> 
> 1) All the units -- packages and procedure -- are at library level.
> 
> 2) The procedure is statically defined and is not going to be 
> 
>    deallocated until the program exits.
> 
> 
> 
> This is very frustrating and would seem to preclude the definition of a procedural access type in a separate definitions package.  The Implementation package (defining procedure Sub but not shown) compiles nicely, btw.
> 
> 
> 
> Is this a problem with Gnat?  If not, how can I do what I want to do?  The attribute Unchecked_Access is not available for subprogram access types.
> 
> 
> 
> -- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[mockturtle]

This came to my mind just after clicking "Post"...

About the fact that   Accessibility_Level_Test is the "main:" I think (but I never tested it) that you could have two legal Ada codes, one that uses Accessibility_Level_Test as "main" and the other that uses it as a "normal" procedure.  (For example, if you use GNAT, the fact that a procedure is a "main" it is written in the project file, not in the Ada source.)  Maybe it is because of this that you cannot exploit the fact that Accessibility_Level_Test is the main.

Riccardo


On Tuesday, September 24, 2013 8:36:43 PM UTC+2, Eryndlia Mavourneen wrote:
> I have a package that defines a single procedure access type:
> 
> 
> 
>    1. package Accessibility_Level_Def is
> 
>    2.   pragma Pure;
> 
>    3.   type Proc_Type is access procedure (An_Str : String);
> 
>    4. end Accessibility_Level_Def;
> 
> 
> 
> I have a main program which references it (and another package):
> 
> 
> 
>     1. with Ada.Text_IO;                        use Ada.Text_IO;
> 
>     2. with Accessibility_Level_Def;            use Accessibility_Level_Def;
> 
>     3. with Accessibility_Level_Implementation; use Accessibility_Level_Implementation;
> 
>     4. procedure Accessibility_Level_Test is
> 
>     5.    procedure Test (Text : String);
> 
>     6.    procedure Test (Text : String) is
> 
>     7.    begin
> 
>     8.       Put_Line ("in Test");
> 
>     9.    end Test;
> 
>    10. 
> 
>    11.    The_Proc : Proc_Type;
> 
>    12. begin
> 
>    13.    The_Proc := Test'Access;
> 
>    14.    Sub (Proc => The_Proc);
> 
>    15. end Accessibility_Level_Test;
> 
> 
> 
> Gnat 2012 (on Ubuntu) gives the error on line 13:
> 
> 
> 
>    "Subprogram must not be deeper than access type."
> 
> 
> 
> I thought I understood accessibility levels, at least, I understood the examples I have found.  Yet, this example appears to not have the same issues:
> 
> 
> 
> 1) All the units -- packages and procedure -- are at library level.
> 
> 2) The procedure is statically defined and is not going to be 
> 
>    deallocated until the program exits.
> 
> 
> 
> This is very frustrating and would seem to preclude the definition of a procedural access type in a separate definitions package.  The Implementation package (defining procedure Sub but not shown) compiles nicely, btw.
> 
> 
> 
> Is this a problem with Gnat?  If not, how can I do what I want to do?  The attribute Unchecked_Access is not available for subprogram access types.
> 
> 
> 
> -- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[Adam Beneschan]

On Tuesday, September 24, 2013 11:54:11 AM UTC-7, Eryndlia Mavourneen wrote:
> Actually, I realize that the nested procedure whose 'Access is taken is not at library level, but it still is frustrating that this obviously(?) safe code is not acceptable to the compiler.
> 
> 
> 
> -- Eryndlia (KK1T)

It's not safe.  You don't give the declaration of "Sub", but if it's something like

    procedure Sub (Proc : Proc_Type);

then for all the compiler knows, Sub could assign some global variable of type Proc_Type to Proc (Glob_Proc := Proc;).  Then an access to Test would exist after Accessibility_Level_Test exited, which is no good (it could be a disaster if the global variable was later used for a procedure call).

                          -- Adam

Re: Accessibility Levels and Library-Level Units

[Eryndlia Mavourneen]

On Tuesday, September 24, 2013 2:13:35 PM UTC-5, mockturtle wrote:
> This came to my mind just after clicking "Post"...
> 
> 
> 
> About the fact that   Accessibility_Level_Test is the "main:" I think (but I never tested it) that you could have two legal Ada codes, one that uses Accessibility_Level_Test as "main" and the other that uses it as a "normal" procedure.  (For example, if you use GNAT, the fact that a procedure is a "main" it is written in the project file, not in the Ada source.)  Maybe it is because of this that you cannot exploit the fact that Accessibility_Level_Test is the main.
> 

OK, I made the procedure Test a true library-level procedure, and it now compiles, although I am not certain that I see the difference in safety.  

-- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[Adam Beneschan]

On Tuesday, September 24, 2013 12:13:35 PM UTC-7, mockturtle wrote:
> This came to my mind just after clicking "Post"...
> 
> 
> 
> About the fact that   Accessibility_Level_Test is the "main:" I think (but I never tested it) that you could have two legal Ada codes, one that uses Accessibility_Level_Test as "main" and the other that uses it as a "normal" procedure.  (For example, if you use GNAT, the fact that a procedure is a "main" it is written in the project file, not in the Ada source.)  Maybe it is because of this that you cannot exploit the fact that Accessibility_Level_Test is the main.

Even if the compiler knew Accessibility_Level_Test were the main subprogram, nothing would prevent some other subprogram from calling it (recursively).  This doesn't commonly happen, though.

                                 -- Adam

Re: Accessibility Levels and Library-Level Units

[Jeffrey Carter]

On 09/24/2013 11:36 AM, Eryndlia Mavourneen wrote:
>
> 1) All the units -- packages and procedure -- are at library level.
> 2) The procedure is statically defined and is not going to be
>    deallocated until the program exits.
>
> This is very frustrating and would seem to preclude the definition of a
> procedural access type in a separate definitions package.  The Implementation
> package (defining procedure Sub but not shown) compiles nicely, btw.
>
> Is this a problem with Gnat?  If not, how can I do what I want to do?  The
> attribute Unchecked_Access is not available for subprogram access types.

Your main-program procedure, while declared at the library level, is not 
necessarily at library level. This is because it is a subprogram, and its 
accessibility level is determined by where and when it is called. Although you 
know that it is only called by the environment task once, the compiler doesn't 
know that, and the language provides no way to tell the compiler that, probably 
because checking it is painful. The procedure could call itself recursively, or 
something else could with it and call it. In either case, the accessibility 
level of the procedure nested within it will not be library level.

There are 2 ways to do what you want: declare the subprogram (whose access value 
will be assigned to the access object) in a library-level package, or use an 
anonymous access-to-subprogram parameter rather than a named 
access-to-subprogram type.

-- 
Jeff Carter
"He didn't get that nose from playing ping-pong."
Never Give a Sucker an Even Break
110

Re: Accessibility Levels and Library-Level Units

[Eryndlia Mavourneen]

Thank you Riccardo, Jeff, & Adam.

Jeff, I thought I had tried it with an anonymous type without success; however, the context in which I have to use this disallows doing that in any case.

-- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[Adam Beneschan]

On Tuesday, September 24, 2013 12:43:37 PM UTC-7, Eryndlia Mavourneen wrote:
> Thank you Riccardo, Jeff, & Adam.
> 
> 
> 
> Jeff, I thought I had tried it with an anonymous type without success; however, the context in which I have to use this disallows doing that in any case.

Note that even if Sub were declared with an anonymous access-to-subprogram type, the code you posted:

   11.    The_Proc : Proc_Type; 
   12. begin 
   13.    The_Proc := Test'Access; 
   14.    Sub (Proc => The_Proc); 

would still be illegal, since the error is on the line that assigns The_Proc := Test'Access.  Getting rid of The_Proc and just calling

   Sub (Proc => Test'Access);

should work in that case.

                                -- Adam

Re: Accessibility Levels and Library-Level Units

[J-P. Rosen]

Le 24/09/2013 21:27, Adam Beneschan a écrit :
> Even if the compiler knew Accessibility_Level_Test were the main
> subprogram, nothing would prevent some other subprogram from calling
> it (recursively).

Even without calling it recursively, exiting the main program is /not/
the end of the execution of an Ada Program. Tasks declared in library
packages continue to run, there are even programs where the main
procedure is begin-null;-end, all the work being done in library tasks.

And of course, such tasks could use the pointer after the main
subprogram is exited.

Library level finalizable objects can also execute code after the main
procedure is exited.

You can think of it this way: the real main program is written by the
compiler; it elaborates library packages, then calls the main procedure,
then finalizes library packages (which involves waiting for the
termination of library tasks).

In Gnat, this main program is written in Ada, and you can find it in the
b~xxx package.
-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: Accessibility Levels and Library-Level Units

[Eryndlia Mavourneen]

On Tuesday, September 24, 2013 3:02:39 PM UTC-5, J-P. Rosen wrote:
> Le 24/09/2013 21:27, Adam Beneschan a �crit :
> 
> > Even if the compiler knew Accessibility_Level_Test were the main
> > subprogram, nothing would prevent some other subprogram from calling
> > it (recursively).
> 
> Even without calling it recursively, exiting the main program is /not/
> the end of the execution of an Ada Program. Tasks declared in library
> packages continue to run, there are even programs where the main
> . . .

Yes, of course.  Thank you J-P.  I was considering only the simple program I had at hand, but you are correct.

-- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[Adam Beneschan]

On Tuesday, September 24, 2013 1:02:39 PM UTC-7, J-P. Rosen wrote:
> Le 24/09/2013 21:27, Adam Beneschan a �crit :
> 
> > Even if the compiler knew Accessibility_Level_Test were the main
> > subprogram, nothing would prevent some other subprogram from calling
> > it (recursively).
> 
> Even without calling it recursively, exiting the main program is /not/
> the end of the execution of an Ada Program. Tasks declared in library
> packages continue to run, there are even programs where the main
> procedure is begin-null;-end, all the work being done in library tasks.
> 
> And of course, such tasks could use the pointer after the main
> subprogram is exited.
> 
> Library level finalizable objects can also execute code after the main
> procedure is exited.

Yes, I'd forgotten about all those cases.  Thanks for pointing it out.

                               -- Adam

Re: Accessibility Levels and Library-Level Units

[Robert A Duff]

Eryndlia Mavourneen <eryndlia@gmail.com> writes:

> Jeff, I thought I had tried it with an anonymous type without success;
> however, the context in which I have to use this disallows doing that
> in any case.

Are you sure?  That would only be true if you're assigning that
access value into some global data structure.  If all you want
to do is call it, an anonymous access type will work, and has the
important advantage that you can pass nested procedures.

The proper syntax is "not null access procedure ...".

- Bob

Re: Accessibility Levels and Library-Level Units

[Dmitry A. Kazakov]

On Tue, 24 Sep 2013 12:06:06 -0700 (PDT), mockturtle wrote:

> I think that the problem is that Test is "local to" (defined inside)
> Accessibility_Level_Test.  The problem is that you could have a
> "perverted" procedure Sub like this
[...]

The problem is language design which forces pointers where none is needed.
If Ada had procedural types no problem would ever arise as, none does when
you pass, say, a Boolean.

Using access-to-procedure for downward closures is an Ada 95 hack. In Ada
83 it was even worse, we had to use tasks!

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Accessibility Levels and Library-Level Units

[Eryndlia Mavourneen]

On Tuesday, September 24, 2013 3:50:24 PM UTC-5, Robert A Duff wrote:
> . . .
> The proper syntax is "not null access procedure ...".
> 
> - Bob

Thanks, but I can't use "not null", since I am limited to Ada95 for this code.

-- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[Robert A Duff]

Eryndlia Mavourneen <eryndlia@gmail.com> writes:

> On Tuesday, September 24, 2013 3:50:24 PM UTC-5, Robert A Duff wrote:
>> . . .
>> The proper syntax is "not null access procedure ...".
>> 
>> - Bob
>
> Thanks, but I can't use "not null", since I am limited to Ada95 for this code.

Then you can't use anonymous access-to-procedure at all,
with or without "not null".

Why are you limited to Ada 95?

- Bob

Re: Accessibility Levels and Library-Level Units

[Eryndlia Mavourneen]

On Wednesday, September 25, 2013 4:34:43 PM UTC-5, Robert A Duff wrote:
> . . .
> Why are you limited to Ada 95?
> . . .
> - Bob

It's code for the U.S.A. military & contractors.

-- Eryndlia (KK1T)

Re: Accessibility Levels and Library-Level Units

[Stephen Leake]

Eryndlia Mavourneen <eryndlia@gmail.com> writes:

> On Wednesday, September 25, 2013 4:34:43 PM UTC-5, Robert A Duff wrote:
>> . . .
>> Why are you limited to Ada 95?
>> . . .
>> - Bob
>
> It's code for the U.S.A. military & contractors.

That doesn't explain why they are limiting you to inferior technology!

Perhaps the real reason is "It's a big bureaucracy that is only
interested in spending money, not building good tools".

-- 
-- Stephe