Re: Obtaining access to protected object

[Adam Beneschan <adam@irvine.com>]

On Jul 9, 7:10 pm, george.p...@gmail.com wrote:
> On Jul 9, 3:27 pm, Adam Beneschan <a...@irvine.com> wrote:
>
> > On Jul 9, 8:33 am, george.p...@gmail.com wrote:
>
> > > The instance may not be aliased, and type itself is not enough to
> > > determine that at compile time.
>
> > Wrong.  The current instance of a protected type is always considered
> > aliased, and 'Access is allowed.  3.10(9/2).
>
> >                              -- Adam
>
> I may be wrong,

You're definitely wrong about the rules.  If there's a possibility
that the rules can allow a programmer to write a legal program that
creates a dangling reference (without involving certain dangerous
features), then the ARG needs to hear about it.  But I don't think
that's the case here.  The biggest problem, as far as I know, with
allowing something to access an unaliased object, is that the compiler
may not realize that something could point to it, and therefore could
optimize certain calculations so that the object doesn't necessarily
hold the right value when expected, which will then be a problem if
the program does a dereference of the access.  However, none of this
reasoning applies to protected types, or task types.

In fact, there would probably be no accessing problem at all if *all*
protected and task objects were considered aliased, even without an
explicit "aliased" keyword.  See AARM 3.10(9.l/2) [that's "nine" "dot"
"the lower-case letter L"]; the ARG actually considered doing this for
all by-reference types (which would include task and protected types,
as well as all tagged types and all limited record types).  They
decided not to do so because of some problems involving private parts.


> but it seems that Aliaseness is guaranteed only within
> the protected body. So taking pointer and spilling it outside of the
> scope (even if allowed) is bad idea IMHO.

See above; there's no danger in letting such pointers outside, even if
the object is not explicitly declared as "aliased".  Were it not for
some problems involving privacy breakage, the ARG saw no danger in
simply decreeing that all protected types, etc., are automatically
aliased.


> If used inside the
> protected body then what's advantage of using pointer vs. referring
> directly?

Because you could have an object of an access-to-protected type that
could, in some instances, be set to the same protected type, or could
be set to point to some other protected type.  Of course there's
little point in setting up a pointer that always refers to the same
object; the idea is that you could modify it to point to something
else.

                                 -- Adam