Re: Q: access to subprogram

[bobduff@world.std.com (Robert A Duff)]

In article <4rd5lu$q4@mulga.cs.mu.OZ.AU>,
Fergus Henderson <fjh@mundook.cs.mu.OZ.AU> wrote:
>What was the safe way that you proposed?

There were two variations, actually.

1. Limited access types.  You would say:

    type T is limited access procedure(...);

T would be limited, meaning no assignment.  Without assignment, you
can't create dangling pointers to procedures.  You could pass values of
type T into subprograms, but all the subprogram could do is call through
that value, or pass it on -- not copy it into a global variable.

2. Access-to-subprogram parameters.  You would say:

    procedure Foo(X: Integer; Y: access procedure(B: Boolean));

This syntax is reminiscent of Pascal's.  There would be a run-time
accessibility check on various operations on Y, just like the access
parameters that DO exist in the language (e.g. "Y: access Integer").
This would allow you to pass procedures around, and call them, as in
option (1).  You could also copy them to *local* variables (that is,
inside Foo, you could say "Local := Local_Access_Type(Y)), but any
attempt to copy to a global variable would require some sort of
type_conversion or whatever that would fail the run-time check.

I preferred option (1) at the time.

Now, GNAT has gone and provided the same capability, using an
implementation-defined attribute (Unrestricted_Access), but
unfortunately, this attribute allows dangling pointers to subprograms,
unlike either of the above options.

- Bob