Differences with/without .all

Differences with/without .all

[Alex R. Mosteo]

Hello people,

Gnat is giving me an error depending on if I use the .all abbreviation or not.
I had the (unresearched) idea that there should be no differences besides the
aesthetic one[*], so I'm not sure if gnat's wrong or I'm (guess what ;) )

One way or the other, I'd like to know the explanation. The particular case
that is giving me problems in GPL 2007 is:

protected type Safe;
type Safe_Access is access all Safe;
function S return Safe_Access;

S.Some_Procedure;
--  This fails with
--  Prefix of protected procedure or entry call must be variable

S.all.Some_Procedure;
--  This compiles and runs OK.

Your judgment?

Alex.

[*] Exception possibly being constructions of this kind:
S.all'Access
which may be not equivalent to the original access type ("S'Type")?

Re: Differences with/without .all

[Randy Brukardt]

"Alex R. Mosteo" <devnull@mailinator.com> wrote in message
news:647ktoF2acjggU1@mid.individual.net...
> Hello people,
>
> Gnat is giving me an error depending on if I use the .all abbreviation or
not.
> I had the (unresearched) idea that there should be no differences besides
the
> aesthetic one[*], so I'm not sure if gnat's wrong or I'm (guess what ;) )
>
> One way or the other, I'd like to know the explanation. The particular
case
> that is giving me problems in GPL 2007 is:
>
> protected type Safe;
> type Safe_Access is access all Safe;
> function S return Safe_Access;
>
> S.Some_Procedure;
> --  This fails with
> --  Prefix of protected procedure or entry call must be variable
>
> S.all.Some_Procedure;
> --  This compiles and runs OK.
>
> Your judgment?

Looks like a bug to me. S.all is not a constant, and neither is
S(implicit.all). But S by itself is a constant. It's an easy mistake to
make, though, we used to have a very similar bug in Janus/Ada.

                         Randy.

Re: Differences with/without .all

[Ludovic Brenta]

Alex R. Mosteo writes:
> Hello people,
>
> Gnat is giving me an error depending on if I use the .all
> abbreviation or not.  I had the (unresearched) idea that there
> should be no differences besides the aesthetic one[*], so I'm not
> sure if gnat's wrong or I'm (guess what ;) )
>
> One way or the other, I'd like to know the explanation. The
> particular case that is giving me problems in GPL 2007 is:
>
> protected type Safe;
> type Safe_Access is access all Safe;
> function S return Safe_Access;
>
> S.Some_Procedure;
> --  This fails with
> --  Prefix of protected procedure or entry call must be variable
>
> S.all.Some_Procedure;
> --  This compiles and runs OK.
>
> Your judgment?

The compiler is correct.

6.4(9): "When there is an actual_parameter_part, the prefix can be an
implicit_dereference of an access-to-subprogram value."

In other words, in the absence of actual parameters, you must use an
explicit_dereference, i.e. you must specify ".all".

-- 
Ludovic Brenta.

Re: Differences with/without .all

[Eric Hughes]

On Mar 17, 2:44 pm, Ludovic Brenta <ludo...@ludovic-brenta.org> wrote:
> The compiler is correct.
>
> 6.4(9): "When there is an actual_parameter_part, the prefix can be an
> implicit_dereference of an access-to-subprogram value."

The compiler is correct to reject the syntax.  The compiler has a
defect, though, in that it states an incorrect reason for rejecting
the syntax.

Eric

Re: Differences with/without .all

[Georg Bauhaus]

Ludovic Brenta wrote:
> Alex R. Mosteo writes:

>> protected type Safe;
>> type Safe_Access is access all Safe;
>> function S return Safe_Access;
>>
>> S.Some_Procedure;
>> --  This fails with
>> --  Prefix of protected procedure or entry call must be variable
>>
> The compiler is correct.
> 
> 6.4(9): "When there is an actual_parameter_part, the prefix can be an
> implicit_dereference of an access-to-subprogram value."

I think the parameter profile of Some_Procedure isn't the
issue here as Some_Procedure is just a procedure of
Safe, but not an access to procedure.
 OTOH, S'Result points to a protected object and procedure
Some_Procedure is invoked with this (variable) object.

FWIW, another compiler is fine with the above.

Re: Differences with/without .all

[Adam Beneschan]

On Mar 17, 1:44 pm, Ludovic Brenta <ludo...@ludovic-brenta.org> wrote:
> Alex R. Mosteo writes:
> > Hello people,
>
> > Gnat is giving me an error depending on if I use the .all
> > abbreviation or not.  I had the (unresearched) idea that there
> > should be no differences besides the aesthetic one[*], so I'm not
> > sure if gnat's wrong or I'm (guess what ;) )
>
> > One way or the other, I'd like to know the explanation. The
> > particular case that is giving me problems in GPL 2007 is:
>
> > protected type Safe;
> > type Safe_Access is access all Safe;
> > function S return Safe_Access;
>
> > S.Some_Procedure;
> > --  This fails with
> > --  Prefix of protected procedure or entry call must be variable
>
> > S.all.Some_Procedure;
> > --  This compiles and runs OK.
>
> > Your judgment?
>
> The compiler is correct.
>
> 6.4(9): "When there is an actual_parameter_part, the prefix can be an
> implicit_dereference of an access-to-subprogram value."
>
> In other words, in the absence of actual parameters, you must use an
> explicit_dereference, i.e. you must specify ".all".

Sorry, this rule doesn't apply.  First of all, it's 6.4(8), not 6.4(9)
[just to help anyone else who wants to look it up].  Second, this rule
applies when an access-to-subprogram value is involved in the
expression---and there are no access-to-subprogram values (or types)
in this example, just an access-to-protected-object.  Perhaps you're
confusing an "access-to-subprogram" with a "function that returns an
access type".

I think the compiler is wrong.

[The main reason for 6.4(8) is: Suppose "Func" denotes an access-to-
function type.  If you say Func(param,param,param), this results in an
implicit dereference of Func, and a call to the function pointed to by
Func.  But you cannot get a call to the function pointed to by Func if
there is no parameter list, even if the function type doesn't have any
parameters, or all parameters have defaults.  You must to say Func.all
in that case.]

                                  -- Adam

Re: Differences with/without .all

[Adam Beneschan]

On Mar 17, 3:51 pm, I <a...@irvine.com> wrote:

> [The main reason for 6.4(8) is: Suppose "Func" denotes an access-to-
> function type.

A bit sloppy of me... of course I meant "a value of an access-to-
function type".

                                 -- Adam

> If you say Func(param,param,param), this results in an
> implicit dereference of Func, and a call to the function pointed to by
> Func.  But you cannot get a call to the function pointed to by Func if
> there is no parameter list, even if the function type doesn't have any
> parameters, or all parameters have defaults.  You must to say Func.all
> in that case.]