Anonymous access types

Anonymous access types

[adam.betts155]

I am having some trouble with anonymous access types, behaviour which
I do not understand. I have 2 questions:

1) This one is bizarre and quite non-deterministic. I *sometimes* get
a "finalize/adjust raised exception" with the following bit of code:

declare
      t_ptr : tree_pointer := new tree'(get_tree(g));
      anon_t_ptr : access tree'class := new tree'(get_tree(g));
      lca : least_common_ancestor(anon_t_ptr);
begin
end;

with the following type declarations:
 tree_pointer is access tree'class;
 type least_common_ancestor (tree_ptr: access constant tree'class);

It seems that there is sometimes a problem with the lca declaration,
since the exception is never raised when anon_t_ptr is replaced with
t_ptr.

2) I want to return an anonymous access type from a function:

function get_tree (g: graph) return non null access tree is
begin
  return new tree(g.t);
end get_tree;

The access type is not null when I use this function. However, when I
run the code and try to do operations on the access type, it is not
pointing in the right place. For example, the returned tree does not
have vertices and edges even though I know it does.

Any help with either of these issues would be greatly appreciated.

Re: Anonymous access types

[Dmitry A. Kazakov]

On Fri, 08 Jun 2007 02:29:48 -0700, adam.betts155@gmail.com wrote:

> I am having some trouble with anonymous access types, behaviour which
> I do not understand. I have 2 questions:
> 
> 1) This one is bizarre and quite non-deterministic. I *sometimes* get
> a "finalize/adjust raised exception" with the following bit of code:
> 
> declare
>       t_ptr : tree_pointer := new tree'(get_tree(g));
>       anon_t_ptr : access tree'class := new tree'(get_tree(g));
>       lca : least_common_ancestor(anon_t_ptr);
> begin
> end;

This leaks, where these objects get deallocated?

> with the following type declarations:
>  tree_pointer is access tree'class;
>  type least_common_ancestor (tree_ptr: access constant tree'class);
> 
> It seems that there is sometimes a problem with the lca declaration,
> since the exception is never raised when anon_t_ptr is replaced with
> t_ptr.

I guess it is because of accessibility checks. t_ptr and anon_t_ptr have
different accessibility levels. When you call to least_common_ancestor,
which probably has its parameter of some access type declared in an
enclosing scope, then anon_t_ptr being converted fails on accessibility
check. In the result you get a snowball of misleading secondary faults.

(never use pointers if you can)

> 2) I want to return an anonymous access type from a function:
> 
> function get_tree (g: graph) return non null access tree is
> begin
>   return new tree(g.t);
> end get_tree;
> 
> The access type is not null when I use this function. However, when I
> run the code and try to do operations on the access type, it is not
> pointing in the right place. For example, the returned tree does not
> have vertices and edges even though I know it does.

   new tree(g.t);

does not initialize the object beyond standard initialization. You probably
meant

   new tree'(<some initial value>);

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

Re: Anonymous access types

[adam.betts155]

On Jun 8, 1:01 pm, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> On Fri, 08 Jun 2007 02:29:48 -0700, adam.betts...@gmail.com wrote:
> > I am having some trouble with anonymous access types, behaviour which
> > I do not understand. I have 2 questions:
>
> > 1) This one is bizarre and quite non-deterministic. I *sometimes* get
> > a "finalize/adjust raised exception" with the following bit of code:
>
> > declare
> >       t_ptr : tree_pointer := new tree'(get_tree(g));
> >       anon_t_ptr : access tree'class := new tree'(get_tree(g));
> >       lca : least_common_ancestor(anon_t_ptr);
> > begin
> > end;
>
> This leaks, where these objects get deallocated?

It was a deallocation problem, thanks

>
> > with the following type declarations:
> >  tree_pointer is access tree'class;
> >  type least_common_ancestor (tree_ptr: access constant tree'class);
>
> > It seems that there is sometimes a problem with the lca declaration,
> > since the exception is never raised when anon_t_ptr is replaced with
> > t_ptr.
>
> I guess it is because of accessibility checks. t_ptr and anon_t_ptr have
> different accessibility levels. When you call to least_common_ancestor,
> which probably has its parameter of some access type declared in an
> enclosing scope, then anon_t_ptr being converted fails on accessibility
> check. In the result you get a snowball of misleading secondary faults.
>
> (never use pointers if you can)
>
> > 2) I want to return an anonymous access type from a function:
>
> > function get_tree (g: graph) return non null access tree is
> > begin
> >   return new tree(g.t);
> > end get_tree;
>
> > The access type is not null when I use this function. However, when I
> > run the code and try to do operations on the access type, it is not
> > pointing in the right place. For example, the returned tree does not
> > have vertices and edges even though I know it does.
>
>    new tree(g.t);
>
> does not initialize the object beyond standard initialization. You probably
> meant
>
>    new tree'(<some initial value>);
>

Yep, sorry, was that a typo on my part. I actually did have:
      new tree'(g.t);
and not:
      new tree(g.t);

Given that, why does the pointer not point to the correct place? Where
is it pointing to since it is clearly not null and must be pointing to
a variable of type tree?

Re: Anonymous access types

[Dmitry A. Kazakov]

On Fri, 08 Jun 2007 05:09:59 -0700, adam.betts155@gmail.com wrote:

> Yep, sorry, was that a typo on my part. I actually did have:
>       new tree'(g.t);
> and not:
>       new tree(g.t);
> 
> Given that, why does the pointer not point to the correct place? Where
> is it pointing to since it is clearly not null and must be pointing to
> a variable of type tree?

Why if it really does? Are you using debugger to verify that?

If g.t is controlled you might need to check what its Adjust does. Is it
deep or shallow copy?

BTW, it is a strange looking design. Provided that get_tree has the copy
semantics, why don't you return the copy, but a pointer to?

function get_tree (g: graph) return tree['Class] is
begin
  return g.t;
end get_tree;

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