Re: Task entries and access to subprograms.

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Alex R. Mosteo" <devnull@mailinator.com> writes:

> I see reading the rationale that here the prohibition is more of a
> convenience for the compiler writers than a true restriction for users.

AARM-9.5.2 explains the reason for the rule.  I'd say "convenience" is
an understatement.  ;-)

13    An entry_declaration in a task declaration shall not contain a
specification for an access parameter (see 3.10).

    13.a Reason: Access parameters for task entries would require a
          complex implementation. For example:

    13.b  task T is
             entry E(Z : access Integer); -- Illegal!
          end T;

    13.c  task body T is
          begin
             declare
                type A is access all Integer;
                X : A;
                Int : aliased Integer;
                task Inner;
                task body Inner is
                begin
                   T.E(Int'Access);
                end Inner;
             begin
                accept E(Z : access Integer) do
                   X := A(Z); -- Accessibility_Check
                end E;
             end;
          end T;

    13.d Implementing the Accessibility_Check inside the
       accept_statement for E is difficult, since one does not know
       whether the entry caller is calling from inside the immediately
       enclosing declare block or from outside it. This means that the
       lexical nesting level associated with the designated object is
       not sufficient to determine whether the Accessibility_Check
       should pass or fail.

    13.e Note that such problems do not arise with protected entries,
       because entry_bodies are always nested immediately within the
       protected_body; they cannot be further nested as can
       accept_statements, nor can they be called from within the
       protected_body (since no entry calls are permitted inside a
       protected_body).

I don't see any reasonable alternative rule, other than to forbid those
pesky nested accept statements, which was not an option because that was
already allowed in Ada 83.

- Bob